{"version":3,"file":"mutative-i64wUei9.js","sources":["../../node_modules/mutative/dist/mutative.esm.mjs"],"sourcesContent":["const Operation = {\n    Remove: 'remove',\n    Replace: 'replace',\n    Add: 'add',\n};\n\n// Don't use `Symbol()` just for 3rd party access the draft\nconst PROXY_DRAFT = Symbol.for('__MUTATIVE_PROXY_DRAFT__');\nconst RAW_RETURN_SYMBOL = Symbol('__MUTATIVE_RAW_RETURN_SYMBOL__');\nconst iteratorSymbol = Symbol.iterator;\nconst dataTypes = {\n    mutable: 'mutable',\n    immutable: 'immutable',\n};\n\nconst internal = {};\n\nfunction has(target, key) {\n    return target instanceof Map\n        ? target.has(key)\n        : Object.prototype.hasOwnProperty.call(target, key);\n}\nfunction getDescriptor(target, key) {\n    if (key in target) {\n        let prototype = Reflect.getPrototypeOf(target);\n        while (prototype) {\n            const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);\n            if (descriptor)\n                return descriptor;\n            prototype = Reflect.getPrototypeOf(prototype);\n        }\n    }\n    return;\n}\nfunction isBaseSetInstance(obj) {\n    return Object.getPrototypeOf(obj) === Set.prototype;\n}\nfunction isBaseMapInstance(obj) {\n    return Object.getPrototypeOf(obj) === Map.prototype;\n}\n\nfunction latest(proxyDraft) {\n    var _a;\n    return (_a = proxyDraft.copy) !== null && _a !== void 0 ? _a : proxyDraft.original;\n}\n/**\n * Check if the value is a draft\n */\nfunction isDraft(target) {\n    return !!getProxyDraft(target);\n}\nfunction getProxyDraft(value) {\n    if (typeof value !== 'object')\n        return null;\n    return value === null || value === void 0 ? void 0 : value[PROXY_DRAFT];\n}\nfunction getValue(value) {\n    var _a;\n    const proxyDraft = getProxyDraft(value);\n    return proxyDraft ? (_a = proxyDraft.copy) !== null && _a !== void 0 ? _a : proxyDraft.original : value;\n}\n/**\n * Check if a value is draftable\n */\nfunction isDraftable(value, options) {\n    if (!value || typeof value !== 'object')\n        return false;\n    let markResult;\n    return (Object.getPrototypeOf(value) === Object.prototype ||\n        Array.isArray(value) ||\n        value instanceof Map ||\n        value instanceof Set ||\n        (!!(options === null || options === void 0 ? void 0 : options.mark) &&\n            ((markResult = options.mark(value, dataTypes)) === dataTypes.immutable ||\n                typeof markResult === 'function')));\n}\nfunction getPath(target, path = []) {\n    if (Object.hasOwnProperty.call(target, 'key')) {\n        // check if the parent is a draft and the original value is not equal to the current value\n        const parentCopy = target.parent.copy;\n        const proxyDraft = getProxyDraft(get(parentCopy, target.key));\n        if (proxyDraft !== null && (proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.original) !== target.original) {\n            return null;\n        }\n        const isSet = target.parent.type === 3 /* DraftType.Set */;\n        const key = isSet\n            ? Array.from(target.parent.setMap.keys()).indexOf(target.key)\n            : target.key;\n        // check if the key is still in the next state parent\n        if (!((isSet && parentCopy.size > key) || has(parentCopy, key)))\n            return null;\n        path.push(key);\n    }\n    if (target.parent) {\n        return getPath(target.parent, path);\n    }\n    // `target` is root draft.\n    path.reverse();\n    try {\n        // check if the path is valid\n        resolvePath(target.copy, path);\n    }\n    catch (e) {\n        return null;\n    }\n    return path;\n}\nfunction getType(target) {\n    if (Array.isArray(target))\n        return 1 /* DraftType.Array */;\n    if (target instanceof Map)\n        return 2 /* DraftType.Map */;\n    if (target instanceof Set)\n        return 3 /* DraftType.Set */;\n    return 0 /* DraftType.Object */;\n}\nfunction get(target, key) {\n    return getType(target) === 2 /* DraftType.Map */ ? target.get(key) : target[key];\n}\nfunction set(target, key, value) {\n    const type = getType(target);\n    if (type === 2 /* DraftType.Map */) {\n        target.set(key, value);\n    }\n    else {\n        target[key] = value;\n    }\n}\nfunction peek(target, key) {\n    const state = getProxyDraft(target);\n    const source = state ? latest(state) : target;\n    return source[key];\n}\nfunction isEqual(x, y) {\n    if (x === y) {\n        return x !== 0 || 1 / x === 1 / y;\n    }\n    else {\n        return x !== x && y !== y;\n    }\n}\nfunction revokeProxy(proxyDraft) {\n    if (!proxyDraft)\n        return;\n    while (proxyDraft.finalities.revoke.length > 0) {\n        const revoke = proxyDraft.finalities.revoke.pop();\n        revoke();\n    }\n}\n// handle JSON Pointer path with spec https://www.rfc-editor.org/rfc/rfc6901\nfunction escapePath(path, pathAsArray) {\n    return pathAsArray\n        ? path\n        : ['']\n            .concat(path)\n            .map((_item) => {\n            const item = `${_item}`;\n            if (item.indexOf('/') === -1 && item.indexOf('~') === -1)\n                return item;\n            return item.replace(/~/g, '~0').replace(/\\//g, '~1');\n        })\n            .join('/');\n}\nfunction unescapePath(path) {\n    if (Array.isArray(path))\n        return path;\n    return path\n        .split('/')\n        .map((_item) => _item.replace(/~1/g, '/').replace(/~0/g, '~'))\n        .slice(1);\n}\nfunction resolvePath(base, path) {\n    for (let index = 0; index < path.length - 1; index += 1) {\n        const key = path[index];\n        // use `index` in Set draft\n        base = get(getType(base) === 3 /* DraftType.Set */ ? Array.from(base) : base, key);\n        if (typeof base !== 'object') {\n            throw new Error(`Cannot resolve patch at '${path.join('/')}'.`);\n        }\n    }\n    return base;\n}\n\nfunction strictCopy(target) {\n    const copy = Object.create(Object.getPrototypeOf(target));\n    Reflect.ownKeys(target).forEach((key) => {\n        let desc = Reflect.getOwnPropertyDescriptor(target, key);\n        if (desc.enumerable && desc.configurable && desc.writable) {\n            copy[key] = target[key];\n            return;\n        }\n        // for freeze\n        if (!desc.writable) {\n            desc.writable = true;\n            desc.configurable = true;\n        }\n        if (desc.get || desc.set)\n            desc = {\n                configurable: true,\n                writable: true,\n                enumerable: desc.enumerable,\n                value: target[key],\n            };\n        Reflect.defineProperty(copy, key, desc);\n    });\n    return copy;\n}\nconst propIsEnum = Object.prototype.propertyIsEnumerable;\nfunction shallowCopy(original, options) {\n    let markResult;\n    if (Array.isArray(original)) {\n        return Array.prototype.concat.call(original);\n    }\n    else if (original instanceof Set) {\n        if (!isBaseSetInstance(original)) {\n            const SubClass = Object.getPrototypeOf(original).constructor;\n            return new SubClass(original.values());\n        }\n        return Set.prototype.difference\n            ? Set.prototype.difference.call(original, new Set())\n            : new Set(original.values());\n    }\n    else if (original instanceof Map) {\n        if (!isBaseMapInstance(original)) {\n            const SubClass = Object.getPrototypeOf(original).constructor;\n            return new SubClass(original);\n        }\n        return new Map(original);\n    }\n    else if ((options === null || options === void 0 ? void 0 : options.mark) &&\n        ((markResult = options.mark(original, dataTypes)),\n            markResult !== undefined) &&\n        markResult !== dataTypes.mutable) {\n        if (markResult === dataTypes.immutable) {\n            return strictCopy(original);\n        }\n        else if (typeof markResult === 'function') {\n            if ((options.enablePatches || options.enableAutoFreeze)) {\n                throw new Error(`You can't use mark and patches or auto freeze together.`);\n            }\n            return markResult();\n        }\n        throw new Error(`Unsupported mark result: ${markResult}`);\n    }\n    else if (typeof original === 'object' &&\n        Object.getPrototypeOf(original) === Object.prototype) {\n        // For best performance with shallow copies,\n        // don't use `Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));` by default.\n        const copy = {};\n        Object.keys(original).forEach((key) => {\n            copy[key] = original[key];\n        });\n        Object.getOwnPropertySymbols(original).forEach((key) => {\n            if (propIsEnum.call(original, key)) {\n                copy[key] = original[key];\n            }\n        });\n        return copy;\n    }\n    else {\n        throw new Error(`Please check mark() to ensure that it is a stable marker draftable function.`);\n    }\n}\nfunction ensureShallowCopy(target) {\n    if (target.copy)\n        return;\n    target.copy = shallowCopy(target.original, target.options);\n}\nfunction deepClone(target) {\n    if (!isDraftable(target))\n        return getValue(target);\n    if (Array.isArray(target))\n        return target.map(deepClone);\n    if (target instanceof Map) {\n        const iterable = Array.from(target.entries()).map(([k, v]) => [\n            k,\n            deepClone(v),\n        ]);\n        if (!isBaseMapInstance(target)) {\n            const SubClass = Object.getPrototypeOf(target).constructor;\n            return new SubClass(iterable);\n        }\n        return new Map(iterable);\n    }\n    if (target instanceof Set) {\n        const iterable = Array.from(target).map(deepClone);\n        if (!isBaseSetInstance(target)) {\n            const SubClass = Object.getPrototypeOf(target).constructor;\n            return new SubClass(iterable);\n        }\n        return new Set(iterable);\n    }\n    const copy = Object.create(Object.getPrototypeOf(target));\n    for (const key in target)\n        copy[key] = deepClone(target[key]);\n    return copy;\n}\nfunction cloneIfNeeded(target) {\n    return isDraft(target) ? deepClone(target) : target;\n}\n\nfunction markChanged(proxyDraft) {\n    var _a;\n    proxyDraft.assignedMap = (_a = proxyDraft.assignedMap) !== null && _a !== void 0 ? _a : new Map();\n    if (!proxyDraft.operated) {\n        proxyDraft.operated = true;\n        if (proxyDraft.parent) {\n            markChanged(proxyDraft.parent);\n        }\n    }\n}\n\nfunction throwFrozenError() {\n    throw new Error('Cannot modify frozen object');\n}\nfunction deepFreeze(target, subKey, updatedValues, stack, keys) {\n    {\n        updatedValues = updatedValues !== null && updatedValues !== void 0 ? updatedValues : new WeakMap();\n        stack = stack !== null && stack !== void 0 ? stack : [];\n        keys = keys !== null && keys !== void 0 ? keys : [];\n        const value = updatedValues.has(target)\n            ? updatedValues.get(target)\n            : target;\n        if (stack.length > 0) {\n            const index = stack.indexOf(value);\n            if (value && typeof value === 'object' && index !== -1) {\n                if (stack[0] === value) {\n                    throw new Error(`Forbids circular reference`);\n                }\n                throw new Error(`Forbids circular reference: ~/${keys\n                    .slice(0, index)\n                    .map((key, index) => {\n                    if (typeof key === 'symbol')\n                        return `[${key.toString()}]`;\n                    const parent = stack[index];\n                    if (typeof key === 'object' &&\n                        (parent instanceof Map || parent instanceof Set))\n                        return Array.from(parent.keys()).indexOf(key);\n                    return key;\n                })\n                    .join('/')}`);\n            }\n            stack.push(value);\n            keys.push(subKey);\n        }\n        else {\n            stack.push(value);\n        }\n    }\n    if (Object.isFrozen(target) || isDraft(target)) {\n        {\n            stack.pop();\n            keys.pop();\n        }\n        return;\n    }\n    const type = getType(target);\n    switch (type) {\n        case 2 /* DraftType.Map */:\n            for (const [key, value] of target) {\n                deepFreeze(key, key, updatedValues, stack, keys);\n                deepFreeze(value, key, updatedValues, stack, keys);\n            }\n            target.set = target.clear = target.delete = throwFrozenError;\n            break;\n        case 3 /* DraftType.Set */:\n            for (const value of target) {\n                deepFreeze(value, value, updatedValues, stack, keys);\n            }\n            target.add = target.clear = target.delete = throwFrozenError;\n            break;\n        case 1 /* DraftType.Array */:\n            Object.freeze(target);\n            let index = 0;\n            for (const value of target) {\n                deepFreeze(value, index, updatedValues, stack, keys);\n                index += 1;\n            }\n            break;\n        default:\n            Object.freeze(target);\n            // ignore non-enumerable or symbol properties\n            Object.keys(target).forEach((name) => {\n                const value = target[name];\n                deepFreeze(value, name, updatedValues, stack, keys);\n            });\n    }\n    {\n        stack.pop();\n        keys.pop();\n    }\n}\n\nfunction forEach(target, iter) {\n    const type = getType(target);\n    if (type === 0 /* DraftType.Object */) {\n        Reflect.ownKeys(target).forEach((key) => {\n            iter(key, target[key], target);\n        });\n    }\n    else if (type === 1 /* DraftType.Array */) {\n        let index = 0;\n        for (const entry of target) {\n            iter(index, entry, target);\n            index += 1;\n        }\n    }\n    else {\n        target.forEach((entry, index) => iter(index, entry, target));\n    }\n}\n\nfunction handleValue(target, handledSet, options) {\n    if (isDraft(target) ||\n        !isDraftable(target, options) ||\n        handledSet.has(target) ||\n        Object.isFrozen(target))\n        return;\n    const isSet = target instanceof Set;\n    const setMap = isSet ? new Map() : undefined;\n    handledSet.add(target);\n    forEach(target, (key, value) => {\n        var _a;\n        if (isDraft(value)) {\n            const proxyDraft = getProxyDraft(value);\n            ensureShallowCopy(proxyDraft);\n            // A draft where a child node has been changed, or assigned a value\n            const updatedValue = ((_a = proxyDraft.assignedMap) === null || _a === void 0 ? void 0 : _a.size) || proxyDraft.operated\n                ? proxyDraft.copy\n                : proxyDraft.original;\n            // final update value\n            set(isSet ? setMap : target, key, updatedValue);\n        }\n        else {\n            handleValue(value, handledSet, options);\n        }\n    });\n    if (setMap) {\n        const set = target;\n        const values = Array.from(set);\n        set.clear();\n        values.forEach((value) => {\n            set.add(setMap.has(value) ? setMap.get(value) : value);\n        });\n    }\n}\nfunction finalizeAssigned(proxyDraft, key) {\n    // handle the draftable assigned values， and the value is not a draft\n    const copy = proxyDraft.type === 3 /* DraftType.Set */ ? proxyDraft.setMap : proxyDraft.copy;\n    if (proxyDraft.finalities.revoke.length > 1 &&\n        proxyDraft.assignedMap.get(key) &&\n        copy) {\n        handleValue(get(copy, key), proxyDraft.finalities.handledSet, proxyDraft.options);\n    }\n}\nfunction finalizeSetValue(target) {\n    if (target.type === 3 /* DraftType.Set */ && target.copy) {\n        target.copy.clear();\n        target.setMap.forEach((value) => {\n            target.copy.add(getValue(value));\n        });\n    }\n}\nfunction finalizePatches(target, generatePatches, patches, inversePatches) {\n    const shouldFinalize = target.operated &&\n        target.assignedMap &&\n        target.assignedMap.size > 0 &&\n        !target.finalized;\n    if (shouldFinalize) {\n        if (patches && inversePatches) {\n            const basePath = getPath(target);\n            if (basePath) {\n                generatePatches(target, basePath, patches, inversePatches);\n            }\n        }\n        target.finalized = true;\n    }\n}\nfunction markFinalization(target, key, value, generatePatches) {\n    const proxyDraft = getProxyDraft(value);\n    if (proxyDraft) {\n        // !case: assign the draft value\n        if (!proxyDraft.callbacks) {\n            proxyDraft.callbacks = [];\n        }\n        proxyDraft.callbacks.push((patches, inversePatches) => {\n            var _a;\n            const copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;\n            if (isEqual(get(copy, key), value)) {\n                let updatedValue = proxyDraft.original;\n                if (proxyDraft.copy) {\n                    updatedValue = proxyDraft.copy;\n                }\n                finalizeSetValue(target);\n                finalizePatches(target, generatePatches, patches, inversePatches);\n                if (target.options.enableAutoFreeze) {\n                    target.options.updatedValues =\n                        (_a = target.options.updatedValues) !== null && _a !== void 0 ? _a : new WeakMap();\n                    target.options.updatedValues.set(updatedValue, proxyDraft.original);\n                }\n                // final update value\n                set(copy, key, updatedValue);\n            }\n        });\n        if (target.options.enableAutoFreeze) {\n            // !case: assign the draft value in cross draft tree\n            if (proxyDraft.finalities !== target.finalities) {\n                target.options.enableAutoFreeze = false;\n            }\n        }\n    }\n    if (isDraftable(value, target.options)) {\n        // !case: assign the non-draft value\n        target.finalities.draft.push(() => {\n            const copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;\n            if (isEqual(get(copy, key), value)) {\n                finalizeAssigned(target, key);\n            }\n        });\n    }\n}\n\nfunction generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray) {\n    let { original, assignedMap, options } = proxyState;\n    let copy = proxyState.copy;\n    if (copy.length < original.length) {\n        [original, copy] = [copy, original];\n        [patches, inversePatches] = [inversePatches, patches];\n    }\n    for (let index = 0; index < original.length; index += 1) {\n        if (assignedMap.get(index.toString()) && copy[index] !== original[index]) {\n            const _path = basePath.concat([index]);\n            const path = escapePath(_path, pathAsArray);\n            patches.push({\n                op: Operation.Replace,\n                path,\n                // If it is a draft, it needs to be deep cloned, and it may also be non-draft.\n                value: cloneIfNeeded(copy[index]),\n            });\n            inversePatches.push({\n                op: Operation.Replace,\n                path,\n                // If it is a draft, it needs to be deep cloned, and it may also be non-draft.\n                value: cloneIfNeeded(original[index]),\n            });\n        }\n    }\n    for (let index = original.length; index < copy.length; index += 1) {\n        const _path = basePath.concat([index]);\n        const path = escapePath(_path, pathAsArray);\n        patches.push({\n            op: Operation.Add,\n            path,\n            // If it is a draft, it needs to be deep cloned, and it may also be non-draft.\n            value: cloneIfNeeded(copy[index]),\n        });\n    }\n    if (original.length < copy.length) {\n        // https://www.rfc-editor.org/rfc/rfc6902#appendix-A.4\n        // For performance, here we only generate an operation that replaces the length of the array,\n        // which is inconsistent with JSON Patch specification\n        const { arrayLengthAssignment = true } = options.enablePatches;\n        if (arrayLengthAssignment) {\n            const _path = basePath.concat(['length']);\n            const path = escapePath(_path, pathAsArray);\n            inversePatches.push({\n                op: Operation.Replace,\n                path,\n                value: original.length,\n            });\n        }\n        else {\n            for (let index = copy.length; original.length < index; index -= 1) {\n                const _path = basePath.concat([index - 1]);\n                const path = escapePath(_path, pathAsArray);\n                inversePatches.push({\n                    op: Operation.Remove,\n                    path,\n                });\n            }\n        }\n    }\n}\nfunction generatePatchesFromAssigned({ original, copy, assignedMap }, basePath, patches, inversePatches, pathAsArray) {\n    assignedMap.forEach((assignedValue, key) => {\n        const originalValue = get(original, key);\n        const value = cloneIfNeeded(get(copy, key));\n        const op = !assignedValue\n            ? Operation.Remove\n            : has(original, key)\n                ? Operation.Replace\n                : Operation.Add;\n        if (isEqual(originalValue, value) && op === Operation.Replace)\n            return;\n        const _path = basePath.concat(key);\n        const path = escapePath(_path, pathAsArray);\n        patches.push(op === Operation.Remove ? { op, path } : { op, path, value });\n        inversePatches.push(op === Operation.Add\n            ? { op: Operation.Remove, path }\n            : op === Operation.Remove\n                ? { op: Operation.Add, path, value: originalValue }\n                : { op: Operation.Replace, path, value: originalValue });\n    });\n}\nfunction generateSetPatches({ original, copy }, basePath, patches, inversePatches, pathAsArray) {\n    let index = 0;\n    original.forEach((value) => {\n        if (!copy.has(value)) {\n            const _path = basePath.concat([index]);\n            const path = escapePath(_path, pathAsArray);\n            patches.push({\n                op: Operation.Remove,\n                path,\n                value,\n            });\n            inversePatches.unshift({\n                op: Operation.Add,\n                path,\n                value,\n            });\n        }\n        index += 1;\n    });\n    index = 0;\n    copy.forEach((value) => {\n        if (!original.has(value)) {\n            const _path = basePath.concat([index]);\n            const path = escapePath(_path, pathAsArray);\n            patches.push({\n                op: Operation.Add,\n                path,\n                value,\n            });\n            inversePatches.unshift({\n                op: Operation.Remove,\n                path,\n                value,\n            });\n        }\n        index += 1;\n    });\n}\nfunction generatePatches(proxyState, basePath, patches, inversePatches) {\n    const { pathAsArray = true } = proxyState.options.enablePatches;\n    switch (proxyState.type) {\n        case 0 /* DraftType.Object */:\n        case 2 /* DraftType.Map */:\n            return generatePatchesFromAssigned(proxyState, basePath, patches, inversePatches, pathAsArray);\n        case 1 /* DraftType.Array */:\n            return generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray);\n        case 3 /* DraftType.Set */:\n            return generateSetPatches(proxyState, basePath, patches, inversePatches, pathAsArray);\n    }\n}\n\nlet readable = false;\nconst checkReadable = (value, options, ignoreCheckDraftable = false) => {\n    if (typeof value === 'object' &&\n        value !== null &&\n        (!isDraftable(value, options) || ignoreCheckDraftable) &&\n        !readable) {\n        throw new Error(`Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.`);\n    }\n};\n/**\n * `unsafe(callback)` to access mutable data directly in strict mode.\n *\n * ## Example\n *\n * ```ts\n * import { create, unsafe } from '../index';\n *\n * class Foobar {\n *   bar = 1;\n * }\n *\n * const baseState = { foobar: new Foobar() };\n * const state = create(\n *   baseState,\n *   (draft) => {\n *    unsafe(() => {\n *      draft.foobar.bar = 2;\n *    });\n *   },\n *   {\n *     strict: true,\n *   }\n * );\n *\n * expect(state).toBe(baseState);\n * expect(state.foobar).toBe(baseState.foobar);\n * expect(state.foobar.bar).toBe(2);\n * ```\n */\nfunction unsafe(callback) {\n    readable = true;\n    let result;\n    try {\n        result = callback();\n    }\n    finally {\n        readable = false;\n    }\n    return result;\n}\n\nconst mapHandler = {\n    get size() {\n        const current = latest(getProxyDraft(this));\n        return current.size;\n    },\n    has(key) {\n        return latest(getProxyDraft(this)).has(key);\n    },\n    set(key, value) {\n        const target = getProxyDraft(this);\n        const source = latest(target);\n        if (!source.has(key) || !isEqual(source.get(key), value)) {\n            ensureShallowCopy(target);\n            markChanged(target);\n            target.assignedMap.set(key, true);\n            target.copy.set(key, value);\n            markFinalization(target, key, value, generatePatches);\n        }\n        return this;\n    },\n    delete(key) {\n        if (!this.has(key)) {\n            return false;\n        }\n        const target = getProxyDraft(this);\n        ensureShallowCopy(target);\n        markChanged(target);\n        if (target.original.has(key)) {\n            target.assignedMap.set(key, false);\n        }\n        else {\n            target.assignedMap.delete(key);\n        }\n        target.copy.delete(key);\n        return true;\n    },\n    clear() {\n        const target = getProxyDraft(this);\n        if (!this.size)\n            return;\n        ensureShallowCopy(target);\n        markChanged(target);\n        target.assignedMap = new Map();\n        for (const [key] of target.original) {\n            target.assignedMap.set(key, false);\n        }\n        target.copy.clear();\n    },\n    forEach(callback, thisArg) {\n        const target = getProxyDraft(this);\n        latest(target).forEach((_value, _key) => {\n            callback.call(thisArg, this.get(_key), _key, this);\n        });\n    },\n    get(key) {\n        var _a, _b;\n        const target = getProxyDraft(this);\n        const value = latest(target).get(key);\n        const mutable = ((_b = (_a = target.options).mark) === null || _b === void 0 ? void 0 : _b.call(_a, value, dataTypes)) === dataTypes.mutable;\n        if (target.options.strict) {\n            checkReadable(value, target.options, mutable);\n        }\n        if (mutable) {\n            return value;\n        }\n        if (target.finalized || !isDraftable(value, target.options)) {\n            return value;\n        }\n        // drafted or reassigned\n        if (value !== target.original.get(key)) {\n            return value;\n        }\n        const draft = internal.createDraft({\n            original: value,\n            parentDraft: target,\n            key,\n            finalities: target.finalities,\n            options: target.options,\n        });\n        ensureShallowCopy(target);\n        target.copy.set(key, draft);\n        return draft;\n    },\n    keys() {\n        return latest(getProxyDraft(this)).keys();\n    },\n    values() {\n        const iterator = this.keys();\n        return {\n            [iteratorSymbol]: () => this.values(),\n            next: () => {\n                const result = iterator.next();\n                if (result.done)\n                    return result;\n                const value = this.get(result.value);\n                return {\n                    done: false,\n                    value,\n                };\n            },\n        };\n    },\n    entries() {\n        const iterator = this.keys();\n        return {\n            [iteratorSymbol]: () => this.entries(),\n            next: () => {\n                const result = iterator.next();\n                if (result.done)\n                    return result;\n                const value = this.get(result.value);\n                return {\n                    done: false,\n                    value: [result.value, value],\n                };\n            },\n        };\n    },\n    [iteratorSymbol]() {\n        return this.entries();\n    },\n};\nconst mapHandlerKeys = Reflect.ownKeys(mapHandler);\n\nconst getNextIterator = (target, iterator, { isValuesIterator }) => () => {\n    var _a, _b;\n    const result = iterator.next();\n    if (result.done)\n        return result;\n    const key = result.value;\n    let value = target.setMap.get(key);\n    const currentDraft = getProxyDraft(value);\n    const mutable = ((_b = (_a = target.options).mark) === null || _b === void 0 ? void 0 : _b.call(_a, value, dataTypes)) === dataTypes.mutable;\n    if (target.options.strict) {\n        checkReadable(key, target.options, mutable);\n    }\n    if (!mutable &&\n        !currentDraft &&\n        isDraftable(key, target.options) &&\n        !target.finalized &&\n        target.original.has(key)) {\n        // draft a draftable original set item\n        const proxy = internal.createDraft({\n            original: key,\n            parentDraft: target,\n            key,\n            finalities: target.finalities,\n            options: target.options,\n        });\n        target.setMap.set(key, proxy);\n        value = proxy;\n    }\n    else if (currentDraft) {\n        // drafted\n        value = currentDraft.proxy;\n    }\n    return {\n        done: false,\n        value: isValuesIterator ? value : [value, value],\n    };\n};\nconst setHandler = {\n    get size() {\n        const target = getProxyDraft(this);\n        return target.setMap.size;\n    },\n    has(value) {\n        const target = getProxyDraft(this);\n        // reassigned or non-draftable values\n        if (target.setMap.has(value))\n            return true;\n        ensureShallowCopy(target);\n        const valueProxyDraft = getProxyDraft(value);\n        // drafted\n        if (valueProxyDraft && target.setMap.has(valueProxyDraft.original))\n            return true;\n        return false;\n    },\n    add(value) {\n        const target = getProxyDraft(this);\n        if (!this.has(value)) {\n            ensureShallowCopy(target);\n            markChanged(target);\n            target.assignedMap.set(value, true);\n            target.setMap.set(value, value);\n            markFinalization(target, value, value, generatePatches);\n        }\n        return this;\n    },\n    delete(value) {\n        if (!this.has(value)) {\n            return false;\n        }\n        const target = getProxyDraft(this);\n        ensureShallowCopy(target);\n        markChanged(target);\n        const valueProxyDraft = getProxyDraft(value);\n        if (valueProxyDraft && target.setMap.has(valueProxyDraft.original)) {\n            // delete drafted\n            target.assignedMap.set(valueProxyDraft.original, false);\n            return target.setMap.delete(valueProxyDraft.original);\n        }\n        if (!valueProxyDraft && target.setMap.has(value)) {\n            // non-draftable values\n            target.assignedMap.set(value, false);\n        }\n        else {\n            // reassigned\n            target.assignedMap.delete(value);\n        }\n        // delete reassigned or non-draftable values\n        return target.setMap.delete(value);\n    },\n    clear() {\n        if (!this.size)\n            return;\n        const target = getProxyDraft(this);\n        ensureShallowCopy(target);\n        markChanged(target);\n        for (const value of target.original) {\n            target.assignedMap.set(value, false);\n        }\n        target.setMap.clear();\n    },\n    values() {\n        const target = getProxyDraft(this);\n        ensureShallowCopy(target);\n        const iterator = target.setMap.keys();\n        return {\n            [Symbol.iterator]: () => this.values(),\n            next: getNextIterator(target, iterator, { isValuesIterator: true }),\n        };\n    },\n    entries() {\n        const target = getProxyDraft(this);\n        ensureShallowCopy(target);\n        const iterator = target.setMap.keys();\n        return {\n            [Symbol.iterator]: () => this.entries(),\n            next: getNextIterator(target, iterator, {\n                isValuesIterator: false,\n            }),\n        };\n    },\n    keys() {\n        return this.values();\n    },\n    [iteratorSymbol]() {\n        return this.values();\n    },\n    forEach(callback, thisArg) {\n        const iterator = this.values();\n        let result = iterator.next();\n        while (!result.done) {\n            callback.call(thisArg, result.value, result.value, this);\n            result = iterator.next();\n        }\n    },\n};\nif (Set.prototype.difference) {\n    // for compatibility with new Set methods\n    // https://github.com/tc39/proposal-set-methods\n    // And `https://github.com/tc39/proposal-set-methods/blob/main/details.md#symbolspecies` has some details about the `@@species` symbol.\n    // So we can't use SubSet instance constructor to get the constructor of the SubSet instance.\n    Object.assign(setHandler, {\n        intersection(other) {\n            return Set.prototype.intersection.call(new Set(this.values()), other);\n        },\n        union(other) {\n            return Set.prototype.union.call(new Set(this.values()), other);\n        },\n        difference(other) {\n            return Set.prototype.difference.call(new Set(this.values()), other);\n        },\n        symmetricDifference(other) {\n            return Set.prototype.symmetricDifference.call(new Set(this.values()), other);\n        },\n        isSubsetOf(other) {\n            return Set.prototype.isSubsetOf.call(new Set(this.values()), other);\n        },\n        isSupersetOf(other) {\n            return Set.prototype.isSupersetOf.call(new Set(this.values()), other);\n        },\n        isDisjointFrom(other) {\n            return Set.prototype.isDisjointFrom.call(new Set(this.values()), other);\n        },\n    });\n}\nconst setHandlerKeys = Reflect.ownKeys(setHandler);\n\nconst draftsCache = new WeakSet();\nconst proxyHandler = {\n    get(target, key, receiver) {\n        var _a, _b;\n        const copy = (_a = target.copy) === null || _a === void 0 ? void 0 : _a[key];\n        // Improve draft reading performance by caching the draft copy.\n        if (copy && draftsCache.has(copy)) {\n            return copy;\n        }\n        if (key === PROXY_DRAFT)\n            return target;\n        let markResult;\n        if (target.options.mark) {\n            // handle `Uncaught TypeError: Method get Map.prototype.size called on incompatible receiver #<Map>`\n            // or `Uncaught TypeError: Method get Set.prototype.size called on incompatible receiver #<Set>`\n            const value = key === 'size' &&\n                (target.original instanceof Map || target.original instanceof Set)\n                ? Reflect.get(target.original, key)\n                : Reflect.get(target.original, key, receiver);\n            markResult = target.options.mark(value, dataTypes);\n            if (markResult === dataTypes.mutable) {\n                if (target.options.strict) {\n                    checkReadable(value, target.options, true);\n                }\n                return value;\n            }\n        }\n        const source = latest(target);\n        if (source instanceof Map && mapHandlerKeys.includes(key)) {\n            if (key === 'size') {\n                return Object.getOwnPropertyDescriptor(mapHandler, 'size').get.call(target.proxy);\n            }\n            const handle = mapHandler[key];\n            if (handle) {\n                return handle.bind(target.proxy);\n            }\n        }\n        if (source instanceof Set && setHandlerKeys.includes(key)) {\n            if (key === 'size') {\n                return Object.getOwnPropertyDescriptor(setHandler, 'size').get.call(target.proxy);\n            }\n            const handle = setHandler[key];\n            if (handle) {\n                return handle.bind(target.proxy);\n            }\n        }\n        if (!has(source, key)) {\n            const desc = getDescriptor(source, key);\n            return desc\n                ? `value` in desc\n                    ? desc.value\n                    : // !case: support for getter\n                        (_b = desc.get) === null || _b === void 0 ? void 0 : _b.call(target.proxy)\n                : undefined;\n        }\n        const value = source[key];\n        if (target.options.strict) {\n            checkReadable(value, target.options);\n        }\n        if (target.finalized || !isDraftable(value, target.options)) {\n            return value;\n        }\n        // Ensure that the assigned values are not drafted\n        if (value === peek(target.original, key)) {\n            ensureShallowCopy(target);\n            target.copy[key] = createDraft({\n                original: target.original[key],\n                parentDraft: target,\n                key: target.type === 1 /* DraftType.Array */ ? Number(key) : key,\n                finalities: target.finalities,\n                options: target.options,\n            });\n            // !case: support for custom shallow copy function\n            if (typeof markResult === 'function') {\n                const subProxyDraft = getProxyDraft(target.copy[key]);\n                ensureShallowCopy(subProxyDraft);\n                // Trigger a custom shallow copy to update to a new copy\n                markChanged(subProxyDraft);\n                return subProxyDraft.copy;\n            }\n            return target.copy[key];\n        }\n        return value;\n    },\n    set(target, key, value) {\n        var _a;\n        if (target.type === 3 /* DraftType.Set */ || target.type === 2 /* DraftType.Map */) {\n            throw new Error(`Map/Set draft does not support any property assignment.`);\n        }\n        let _key;\n        if (target.type === 1 /* DraftType.Array */ &&\n            key !== 'length' &&\n            !(Number.isInteger((_key = Number(key))) &&\n                _key >= 0 &&\n                (key === 0 || _key === 0 || String(_key) === String(key)))) {\n            throw new Error(`Only supports setting array indices and the 'length' property.`);\n        }\n        const desc = getDescriptor(latest(target), key);\n        if (desc === null || desc === void 0 ? void 0 : desc.set) {\n            // !case: cover the case of setter\n            desc.set.call(target.proxy, value);\n            return true;\n        }\n        const current = peek(latest(target), key);\n        const currentProxyDraft = getProxyDraft(current);\n        if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {\n            // !case: ignore the case of assigning the original draftable value to a draft\n            target.copy[key] = value;\n            target.assignedMap = (_a = target.assignedMap) !== null && _a !== void 0 ? _a : new Map();\n            target.assignedMap.set(key, false);\n            return true;\n        }\n        // !case: handle new props with value 'undefined'\n        if (isEqual(value, current) &&\n            (value !== undefined || has(target.original, key)))\n            return true;\n        ensureShallowCopy(target);\n        markChanged(target);\n        if (has(target.original, key) && isEqual(value, target.original[key])) {\n            // !case: handle the case of assigning the original non-draftable value to a draft\n            target.assignedMap.delete(key);\n        }\n        else {\n            target.assignedMap.set(key, true);\n        }\n        target.copy[key] = value;\n        markFinalization(target, key, value, generatePatches);\n        return true;\n    },\n    has(target, key) {\n        return key in latest(target);\n    },\n    ownKeys(target) {\n        return Reflect.ownKeys(latest(target));\n    },\n    getOwnPropertyDescriptor(target, key) {\n        const source = latest(target);\n        const descriptor = Reflect.getOwnPropertyDescriptor(source, key);\n        if (!descriptor)\n            return descriptor;\n        return {\n            writable: true,\n            configurable: target.type !== 1 /* DraftType.Array */ || key !== 'length',\n            enumerable: descriptor.enumerable,\n            value: source[key],\n        };\n    },\n    getPrototypeOf(target) {\n        return Reflect.getPrototypeOf(target.original);\n    },\n    setPrototypeOf() {\n        throw new Error(`Cannot call 'setPrototypeOf()' on drafts`);\n    },\n    defineProperty() {\n        throw new Error(`Cannot call 'defineProperty()' on drafts`);\n    },\n    deleteProperty(target, key) {\n        var _a;\n        if (target.type === 1 /* DraftType.Array */) {\n            return proxyHandler.set.call(this, target, key, undefined, target.proxy);\n        }\n        if (peek(target.original, key) !== undefined || key in target.original) {\n            // !case: delete an existing key\n            ensureShallowCopy(target);\n            markChanged(target);\n            target.assignedMap.set(key, false);\n        }\n        else {\n            target.assignedMap = (_a = target.assignedMap) !== null && _a !== void 0 ? _a : new Map();\n            // The original non-existent key has been deleted\n            target.assignedMap.delete(key);\n        }\n        if (target.copy)\n            delete target.copy[key];\n        return true;\n    },\n};\nfunction createDraft(createDraftOptions) {\n    const { original, parentDraft, key, finalities, options } = createDraftOptions;\n    const type = getType(original);\n    const proxyDraft = {\n        type,\n        finalized: false,\n        parent: parentDraft,\n        original,\n        copy: null,\n        proxy: null,\n        finalities,\n        options,\n        // Mapping of draft Set items to their corresponding draft values.\n        setMap: type === 3 /* DraftType.Set */\n            ? new Map(original.entries())\n            : undefined,\n    };\n    // !case: undefined as a draft map key\n    if (key || 'key' in createDraftOptions) {\n        proxyDraft.key = key;\n    }\n    const { proxy, revoke } = Proxy.revocable(type === 1 /* DraftType.Array */ ? Object.assign([], proxyDraft) : proxyDraft, proxyHandler);\n    finalities.revoke.push(revoke);\n    draftsCache.add(proxy);\n    proxyDraft.proxy = proxy;\n    if (parentDraft) {\n        const target = parentDraft;\n        target.finalities.draft.push((patches, inversePatches) => {\n            var _a, _b;\n            const oldProxyDraft = getProxyDraft(proxy);\n            // if target is a Set draft, `setMap` is the real Set copies proxy mapping.\n            let copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;\n            const draft = get(copy, key);\n            const proxyDraft = getProxyDraft(draft);\n            if (proxyDraft) {\n                // assign the updated value to the copy object\n                let updatedValue = proxyDraft.original;\n                if (proxyDraft.operated) {\n                    updatedValue = getValue(draft);\n                }\n                finalizeSetValue(proxyDraft);\n                finalizePatches(proxyDraft, generatePatches, patches, inversePatches);\n                if (target.options.enableAutoFreeze) {\n                    target.options.updatedValues =\n                        (_a = target.options.updatedValues) !== null && _a !== void 0 ? _a : new WeakMap();\n                    target.options.updatedValues.set(updatedValue, proxyDraft.original);\n                }\n                // final update value\n                set(copy, key, updatedValue);\n            }\n            // !case: handle the deleted key\n            (_b = oldProxyDraft.callbacks) === null || _b === void 0 ? void 0 : _b.forEach((callback) => {\n                callback(patches, inversePatches);\n            });\n        });\n    }\n    else {\n        // !case: handle the root draft\n        const target = getProxyDraft(proxy);\n        target.finalities.draft.push((patches, inversePatches) => {\n            finalizeSetValue(target);\n            finalizePatches(target, generatePatches, patches, inversePatches);\n        });\n    }\n    return proxy;\n}\ninternal.createDraft = createDraft;\nfunction finalizeDraft(result, returnedValue, patches, inversePatches, enableAutoFreeze) {\n    var _a;\n    const proxyDraft = getProxyDraft(result);\n    const original = (_a = proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.original) !== null && _a !== void 0 ? _a : result;\n    const hasReturnedValue = !!returnedValue.length;\n    if (proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.operated) {\n        while (proxyDraft.finalities.draft.length > 0) {\n            const finalize = proxyDraft.finalities.draft.pop();\n            finalize(patches, inversePatches);\n        }\n    }\n    const state = hasReturnedValue\n        ? returnedValue[0]\n        : proxyDraft\n            ? proxyDraft.operated\n                ? proxyDraft.copy\n                : proxyDraft.original\n            : result;\n    if (proxyDraft)\n        revokeProxy(proxyDraft);\n    if (enableAutoFreeze) {\n        deepFreeze(state, state, proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.options.updatedValues);\n    }\n    return [\n        state,\n        patches && hasReturnedValue\n            ? [{ op: Operation.Replace, path: [], value: returnedValue[0] }]\n            : patches,\n        inversePatches && hasReturnedValue\n            ? [{ op: Operation.Replace, path: [], value: original }]\n            : inversePatches,\n    ];\n}\n\nfunction draftify(baseState, options) {\n    var _a;\n    const finalities = {\n        draft: [],\n        revoke: [],\n        handledSet: new WeakSet(),\n    };\n    let patches;\n    let inversePatches;\n    if (options.enablePatches) {\n        patches = [];\n        inversePatches = [];\n    }\n    const isMutable = ((_a = options.mark) === null || _a === void 0 ? void 0 : _a.call(options, baseState, dataTypes)) === dataTypes.mutable ||\n        !isDraftable(baseState, options);\n    const draft = isMutable\n        ? baseState\n        : createDraft({\n            original: baseState,\n            parentDraft: null,\n            finalities,\n            options,\n        });\n    return [\n        draft,\n        (returnedValue = []) => {\n            const [finalizedState, finalizedPatches, finalizedInversePatches] = finalizeDraft(draft, returnedValue, patches, inversePatches, options.enableAutoFreeze);\n            return (options.enablePatches\n                ? [finalizedState, finalizedPatches, finalizedInversePatches]\n                : finalizedState);\n        },\n    ];\n}\n\nfunction handleReturnValue(options) {\n    const { rootDraft, value, useRawReturn = false, isRoot = true } = options;\n    forEach(value, (key, item, source) => {\n        const proxyDraft = getProxyDraft(item);\n        // just handle the draft which is created by the same rootDraft\n        if (proxyDraft &&\n            rootDraft &&\n            proxyDraft.finalities === rootDraft.finalities) {\n            options.isContainDraft = true;\n            const currentValue = proxyDraft.original;\n            // final update value, but just handle return value\n            if (source instanceof Set) {\n                const arr = Array.from(source);\n                source.clear();\n                arr.forEach((_item) => source.add(key === _item ? currentValue : _item));\n            }\n            else {\n                set(source, key, currentValue);\n            }\n        }\n        else if (typeof item === 'object' && item !== null) {\n            options.value = item;\n            options.isRoot = false;\n            handleReturnValue(options);\n        }\n    });\n    if (isRoot) {\n        if (!options.isContainDraft)\n            console.warn(`The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance.`);\n        if (useRawReturn) {\n            console.warn(`The return value contains drafts, please don't use 'rawReturn()' to wrap the return value.`);\n        }\n    }\n}\nfunction getCurrent(target) {\n    var _a;\n    const proxyDraft = getProxyDraft(target);\n    if (!isDraftable(target, proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.options))\n        return target;\n    const type = getType(target);\n    if (proxyDraft && !proxyDraft.operated)\n        return proxyDraft.original;\n    let currentValue;\n    function ensureShallowCopy() {\n        currentValue =\n            type === 2 /* DraftType.Map */\n                ? !isBaseMapInstance(target)\n                    ? new (Object.getPrototypeOf(target).constructor)(target)\n                    : new Map(target)\n                : type === 3 /* DraftType.Set */\n                    ? Array.from(proxyDraft.setMap.values())\n                    : shallowCopy(target, proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.options);\n    }\n    if (proxyDraft) {\n        // It's a proxy draft, let's create a shallow copy eagerly\n        proxyDraft.finalized = true;\n        try {\n            ensureShallowCopy();\n        }\n        finally {\n            proxyDraft.finalized = false;\n        }\n    }\n    else {\n        // It's not a proxy draft, let's use the target directly and let's see\n        // lazily if we need to create a shallow copy\n        currentValue = target;\n    }\n    forEach(currentValue, (key, value) => {\n        if (proxyDraft && isEqual(get(proxyDraft.original, key), value))\n            return;\n        const newValue = getCurrent(value);\n        if (newValue !== value) {\n            if (currentValue === target)\n                ensureShallowCopy();\n            set(currentValue, key, newValue);\n        }\n    });\n    if (type === 3 /* DraftType.Set */) {\n        const value = (_a = proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.original) !== null && _a !== void 0 ? _a : currentValue;\n        return !isBaseSetInstance(value)\n            ? new (Object.getPrototypeOf(value).constructor)(currentValue)\n            : new Set(currentValue);\n    }\n    return currentValue;\n}\nfunction current(target) {\n    if (!isDraft(target)) {\n        throw new Error(`current() is only used for Draft, parameter: ${target}`);\n    }\n    return getCurrent(target);\n}\n\n/**\n * `makeCreator(options)` to make a creator function.\n *\n * ## Example\n *\n * ```ts\n * import { makeCreator } from '../index';\n *\n * const baseState = { foo: { bar: 'str' }, arr: [] };\n * const create = makeCreator({ enableAutoFreeze: true });\n * const state = create(\n *   baseState,\n *   (draft) => {\n *     draft.foo.bar = 'str2';\n *   },\n * );\n *\n * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });\n * expect(state).not.toBe(baseState);\n * expect(state.foo).not.toBe(baseState.foo);\n * expect(state.arr).toBe(baseState.arr);\n * expect(Object.isFrozen(state)).toBeTruthy();\n * ```\n */\nconst makeCreator = (arg) => {\n    if (arg !== undefined &&\n        Object.prototype.toString.call(arg) !== '[object Object]') {\n        throw new Error(`Invalid options: ${String(arg)}, 'options' should be an object.`);\n    }\n    return function create(arg0, arg1, arg2) {\n        var _a, _b, _c;\n        if (typeof arg0 === 'function' && typeof arg1 !== 'function') {\n            return function (base, ...args) {\n                return create(base, (draft) => arg0.call(this, draft, ...args), arg1);\n            };\n        }\n        const base = arg0;\n        const mutate = arg1;\n        let options = arg2;\n        if (typeof arg1 !== 'function') {\n            options = arg1;\n        }\n        if (options !== undefined &&\n            Object.prototype.toString.call(options) !== '[object Object]') {\n            throw new Error(`Invalid options: ${options}, 'options' should be an object.`);\n        }\n        options = Object.assign(Object.assign({}, arg), options);\n        const state = isDraft(base) ? current(base) : base;\n        const mark = Array.isArray(options.mark)\n            ? ((value, types) => {\n                for (const mark of options.mark) {\n                    if (typeof mark !== 'function') {\n                        throw new Error(`Invalid mark: ${mark}, 'mark' should be a function.`);\n                    }\n                    const result = mark(value, types);\n                    if (result) {\n                        return result;\n                    }\n                }\n                return;\n            })\n            : options.mark;\n        const enablePatches = (_a = options.enablePatches) !== null && _a !== void 0 ? _a : false;\n        const strict = (_b = options.strict) !== null && _b !== void 0 ? _b : false;\n        const enableAutoFreeze = (_c = options.enableAutoFreeze) !== null && _c !== void 0 ? _c : false;\n        const _options = {\n            enableAutoFreeze,\n            mark,\n            strict,\n            enablePatches,\n        };\n        if (!isDraftable(state, _options) &&\n            typeof state === 'object' &&\n            state !== null) {\n            throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);\n        }\n        const [draft, finalize] = draftify(state, _options);\n        if (typeof arg1 !== 'function') {\n            if (!isDraftable(state, _options)) {\n                throw new Error(`Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`);\n            }\n            return [draft, finalize];\n        }\n        let result;\n        try {\n            result = mutate(draft);\n        }\n        catch (error) {\n            revokeProxy(getProxyDraft(draft));\n            throw error;\n        }\n        const returnValue = (value) => {\n            const proxyDraft = getProxyDraft(draft);\n            if (!isDraft(value)) {\n                if (value !== undefined &&\n                    !isEqual(value, draft) &&\n                    (proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.operated)) {\n                    throw new Error(`Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`);\n                }\n                const rawReturnValue = value === null || value === void 0 ? void 0 : value[RAW_RETURN_SYMBOL];\n                if (rawReturnValue) {\n                    const _value = rawReturnValue[0];\n                    if (_options.strict && typeof value === 'object' && value !== null) {\n                        handleReturnValue({\n                            rootDraft: proxyDraft,\n                            value,\n                            useRawReturn: true,\n                        });\n                    }\n                    return finalize([_value]);\n                }\n                if (value !== undefined) {\n                    if (typeof value === 'object' && value !== null) {\n                        handleReturnValue({ rootDraft: proxyDraft, value });\n                    }\n                    return finalize([value]);\n                }\n            }\n            if (value === draft || value === undefined) {\n                return finalize([]);\n            }\n            const returnedProxyDraft = getProxyDraft(value);\n            if (_options === returnedProxyDraft.options) {\n                if (returnedProxyDraft.operated) {\n                    throw new Error(`Cannot return a modified child draft.`);\n                }\n                return finalize([current(value)]);\n            }\n            return finalize([value]);\n        };\n        if (result instanceof Promise) {\n            return result.then(returnValue, (error) => {\n                revokeProxy(getProxyDraft(draft));\n                throw error;\n            });\n        }\n        return returnValue(result);\n    };\n};\n\n/**\n * `create(baseState, callback, options)` to create the next state\n *\n * ## Example\n *\n * ```ts\n * import { create } from '../index';\n *\n * const baseState = { foo: { bar: 'str' }, arr: [] };\n * const state = create(\n *   baseState,\n *   (draft) => {\n *     draft.foo.bar = 'str2';\n *   },\n * );\n *\n * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });\n * expect(state).not.toBe(baseState);\n * expect(state.foo).not.toBe(baseState.foo);\n * expect(state.arr).toBe(baseState.arr);\n * ```\n */\nconst create = makeCreator();\n\n/**\n * `apply(state, patches)` to apply patches to state\n *\n * ## Example\n *\n * ```ts\n * import { create, apply } from '../index';\n *\n * const baseState = { foo: { bar: 'str' }, arr: [] };\n * const [state, patches] = create(\n *   baseState,\n *   (draft) => {\n *     draft.foo.bar = 'str2';\n *   },\n *   { enablePatches: true }\n * );\n * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });\n * expect(patches).toEqual([{ op: 'replace', path: ['foo', 'bar'], value: 'str2' }]);\n * expect(state).toEqual(apply(baseState, patches));\n * ```\n */\nfunction apply(state, patches, applyOptions) {\n    let i;\n    for (i = patches.length - 1; i >= 0; i -= 1) {\n        const { value, op, path } = patches[i];\n        if ((!path.length && op === Operation.Replace) ||\n            (path === '' && op === Operation.Add)) {\n            state = value;\n            break;\n        }\n    }\n    if (i > -1) {\n        patches = patches.slice(i + 1);\n    }\n    const mutate = (draft) => {\n        patches.forEach((patch) => {\n            const { path: _path, op } = patch;\n            const path = unescapePath(_path);\n            let base = draft;\n            for (let index = 0; index < path.length - 1; index += 1) {\n                const parentType = getType(base);\n                let key = path[index];\n                if (typeof key !== 'string' && typeof key !== 'number') {\n                    key = String(key);\n                }\n                if (((parentType === 0 /* DraftType.Object */ ||\n                    parentType === 1 /* DraftType.Array */) &&\n                    (key === '__proto__' || key === 'constructor')) ||\n                    (typeof base === 'function' && key === 'prototype')) {\n                    throw new Error(`Patching reserved attributes like __proto__ and constructor is not allowed.`);\n                }\n                // use `index` in Set draft\n                base = get(parentType === 3 /* DraftType.Set */ ? Array.from(base) : base, key);\n                if (typeof base !== 'object') {\n                    throw new Error(`Cannot apply patch at '${path.join('/')}'.`);\n                }\n            }\n            const type = getType(base);\n            // ensure the original patch is not modified.\n            const value = deepClone(patch.value);\n            const key = path[path.length - 1];\n            switch (op) {\n                case Operation.Replace:\n                    switch (type) {\n                        case 2 /* DraftType.Map */:\n                            return base.set(key, value);\n                        case 3 /* DraftType.Set */:\n                            throw new Error(`Cannot apply replace patch to set.`);\n                        default:\n                            return (base[key] = value);\n                    }\n                case Operation.Add:\n                    switch (type) {\n                        case 1 /* DraftType.Array */:\n                            // If the \"-\" character is used to\n                            // index the end of the array (see [RFC6901](https://datatracker.ietf.org/doc/html/rfc6902)),\n                            // this has the effect of appending the value to the array.\n                            return key === '-'\n                                ? base.push(value)\n                                : base.splice(key, 0, value);\n                        case 2 /* DraftType.Map */:\n                            return base.set(key, value);\n                        case 3 /* DraftType.Set */:\n                            return base.add(value);\n                        default:\n                            return (base[key] = value);\n                    }\n                case Operation.Remove:\n                    switch (type) {\n                        case 1 /* DraftType.Array */:\n                            return base.splice(key, 1);\n                        case 2 /* DraftType.Map */:\n                            return base.delete(key);\n                        case 3 /* DraftType.Set */:\n                            return base.delete(patch.value);\n                        default:\n                            return delete base[key];\n                    }\n                default:\n                    throw new Error(`Unsupported patch operation: ${op}.`);\n            }\n        });\n    };\n    if (isDraft(state)) {\n        if (applyOptions !== undefined) {\n            throw new Error(`Cannot apply patches with options to a draft.`);\n        }\n        mutate(state);\n        return state;\n    }\n    return create(state, mutate, Object.assign(Object.assign({}, applyOptions), { enablePatches: false }));\n}\n\n/**\n * `original(draft)` to get original state in the draft mutation function.\n *\n * ## Example\n *\n * ```ts\n * import { create, original } from '../index';\n *\n * const baseState = { foo: { bar: 'str' }, arr: [] };\n * const state = create(\n *   baseState,\n *   (draft) => {\n *     draft.foo.bar = 'str2';\n *     expect(original(draft.foo)).toEqual({ bar: 'str' });\n *   }\n * );\n * ```\n */\nfunction original(target) {\n    const proxyDraft = getProxyDraft(target);\n    if (!proxyDraft) {\n        throw new Error(`original() is only used for a draft, parameter: ${target}`);\n    }\n    return proxyDraft.original;\n}\n\n/**\n * Use rawReturn() to wrap the return value to skip the draft check and thus improve performance.\n *\n * ## Example\n *\n * ```ts\n * import { create, rawReturn } from '../index';\n *\n * const baseState = { foo: { bar: 'str' }, arr: [] };\n * const state = create(\n *   baseState,\n *   (draft) => {\n *     return rawReturn(baseState);\n *   },\n * );\n * expect(state).toBe(baseState);\n * ```\n */\nfunction rawReturn(value) {\n    if (arguments.length === 0) {\n        throw new Error('rawReturn() must be called with a value.');\n    }\n    if (arguments.length > 1) {\n        throw new Error('rawReturn() must be called with one argument.');\n    }\n    if (value !== undefined &&\n        (typeof value !== 'object' || value === null)) {\n        console.warn('rawReturn() must be called with an object(including plain object, arrays, Set, Map, etc.) or `undefined`, other types do not need to be returned via rawReturn().');\n    }\n    return {\n        [RAW_RETURN_SYMBOL]: [value],\n    };\n}\n\nconst constructorString = Object.prototype.constructor.toString();\n/**\n * Check if the value is a simple object(No prototype chain object or iframe same-origin object),\n * support case: https://github.com/unadlib/mutative/issues/17\n */\nconst isSimpleObject = (value) => {\n    if (!value || typeof value !== 'object')\n        return false;\n    const prototype = Object.getPrototypeOf(value);\n    if (prototype === null) {\n        return true;\n    }\n    const constructor = Object.hasOwnProperty.call(prototype, 'constructor') &&\n        prototype.constructor;\n    if (constructor === Object)\n        return true;\n    return (typeof constructor === 'function' &&\n        Function.toString.call(constructor) === constructorString);\n};\nconst markSimpleObject = (value) => {\n    if (isSimpleObject(value)) {\n        return dataTypes.immutable;\n    }\n    return;\n};\n\n/**\n * Cast a value to an Draft type value.\n */\nfunction castDraft(value) {\n    return value;\n}\n/**\n * Cast a value to an Immutable type value.\n */\nfunction castImmutable(value) {\n    return value;\n}\n/**\n * Cast a value to an Mutable type value.\n */\nfunction castMutable(draft) {\n    return draft;\n}\n\nexport { apply, castDraft, castImmutable, castMutable, create, current, isDraft, isDraftable, makeCreator, markSimpleObject, original, rawReturn, unsafe };\n//# sourceMappingURL=mutative.esm.mjs.map\n"],"names":["Operation","Remove","Replace","Add","PROXY_DRAFT","Symbol","for","RAW_RETURN_SYMBOL","iteratorSymbol","iterator","dataTypes","mutable","immutable","internal","has","target","key","Map","Object","prototype","hasOwnProperty","call","getDescriptor","Reflect","getPrototypeOf","descriptor","getOwnPropertyDescriptor","isBaseSetInstance","obj","Set","isBaseMapInstance","latest","proxyDraft","_a","copy","original","isDraft","getProxyDraft","value","getValue","isDraftable","options","markResult","Array","isArray","mark","getPath","path","parentCopy","parent","get","isSet","type","from","setMap","keys","indexOf","size","push","reverse","base","index","length","getType","Error","join","resolvePath","e","set","peek","state","isEqual","x","y","revokeProxy","finalities","revoke","pop","escapePath","pathAsArray","concat","map","_item","item","replace","propIsEnum","propertyIsEnumerable","shallowCopy","SubClass","constructor","values","difference","create","ownKeys","forEach","desc","enumerable","configurable","writable","defineProperty","strictCopy","enablePatches","enableAutoFreeze","getOwnPropertySymbols","ensureShallowCopy","deepClone","iterable","entries","k","v","cloneIfNeeded","markChanged","assignedMap","operated","throwFrozenError","deepFreeze","subKey","updatedValues","stack","WeakMap","slice","toString","isFrozen","clear","delete","add","freeze","name","iter","entry","handleValue","handledSet","updatedValue","finalizeAssigned","finalizeSetValue","finalizePatches","generatePatches","patches","inversePatches","finalized","basePath","markFinalization","callbacks","draft","proxyState","assignedValue","originalValue","op","generatePatchesFromAssigned","arrayLengthAssignment","generateArrayPatches","unshift","generateSetPatches","checkReadable","ignoreCheckDraftable","mapHandler","this","source","callback","thisArg","_value","_key","_b","strict","createDraft","parentDraft","next","result","done","mapHandlerKeys","getNextIterator","isValuesIterator","currentDraft","proxy","setHandler","valueProxyDraft","assign","intersection","other","union","symmetricDifference","isSubsetOf","isSupersetOf","isDisjointFrom","setHandlerKeys","draftsCache","WeakSet","proxyHandler","receiver","includes","handle","bind","Number","subProxyDraft","isInteger","String","current","currentProxyDraft","setPrototypeOf","deleteProperty","createDraftOptions","Proxy","revocable","oldProxyDraft","finalizeDraft","returnedValue","hasReturnedValue","finalize","handleReturnValue","rootDraft","useRawReturn","isRoot","isContainDraft","currentValue","arr","console","warn","getCurrent","newValue","arg0","arg1","arg2","_c","args","mutate","arg","types","_options","baseState","finalizedState","finalizedPatches","finalizedInversePatches","draftify","error","returnValue","rawReturnValue","returnedProxyDraft","Promise","then"],"mappings":"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","x_google_ignoreList":[0]}