@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/mutative/dist/mutative.cjs.development.js

@@ -0,0 +1,2126 @@
+"use strict";
+
+//#region src/interface.ts
+const Operation = {
+	Remove: "remove",
+	Replace: "replace",
+	Add: "add"
+};
+
+//#endregion
+//#region src/constant.ts
+const PROXY_DRAFT = Symbol.for("__MUTATIVE_PROXY_DRAFT__");
+const RAW_RETURN_SYMBOL = Symbol("__MUTATIVE_RAW_RETURN_SYMBOL__");
+const iteratorSymbol = Symbol.iterator;
+const iteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][iteratorSymbol]()));
+const dataTypes = {
+	mutable: "mutable",
+	immutable: "immutable"
+};
+
+//#endregion
+//#region src/internal.ts
+const internal = {};
+
+//#endregion
+//#region src/utils/draft.ts
+function latest(proxyDraft) {
+	var _a;
+	return (_a = proxyDraft.copy) !== null && _a !== void 0 ? _a : proxyDraft.original;
+}
+function getSetMap(target) {
+	return target.setMap || (target.setMap = /* @__PURE__ */ new Map());
+}
+function setItemValue(target, item) {
+	const value = target.setMap && target.setMap.get(item);
+	return value === void 0 ? item : value;
+}
+const setValues = Set.prototype.values;
+function iterateSet(set) {
+	return isDraft(set) ? set.values() : setValues.call(set);
+}
+/**
+* Check if the value is a draft
+*/
+function isDraft(target) {
+	return !!getProxyDraft(target);
+}
+function getProxyDraft(value) {
+	if (typeof value !== "object") return null;
+	return value === null || value === void 0 ? void 0 : value[PROXY_DRAFT];
+}
+function assertDraftActive(target) {
+	if (target.finalities.revoke.length === 0) getProxyDraft(target.proxy);
+}
+function getValue(value) {
+	const proxyDraft = getProxyDraft(value);
+	if (!proxyDraft) return value;
+	return proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+}
+/**
+* Check if a value is draftable
+*/
+function isDraftable(value, options) {
+	if (!value || typeof value !== "object") return false;
+	let markResult;
+	return Object.getPrototypeOf(value) === Object.prototype || Array.isArray(value) || value instanceof Map || value instanceof Set || !!(options === null || options === void 0 ? void 0 : options.mark) && ((markResult = options.mark(value, dataTypes)) === dataTypes.immutable || typeof markResult === "function");
+}
+function checkPathKey(type, key, pathAsArray) {
+	if (pathAsArray === false && typeof key !== "string" && (type === 2 || typeof key === "symbol")) throw new Error(`Patches with string paths only support string Map keys and no symbol keys, got a key of type '${typeof key}'. Set 'pathAsArray' to true to keep keys of other types.`);
+}
+function getPath(target, path = []) {
+	const parent = target.parent;
+	if (parent) {
+		const parentCopy = parent.copy;
+		let key = target.key;
+		if (parent.type === 3) {
+			if (parent.assignedMap.size > 0) return null;
+			let index = 0;
+			for (const item of iterateSet(parent.original)) {
+				if (item === key) break;
+				index += 1;
+			}
+			key = index;
+		} else if (get(parentCopy, key) !== target.proxy) return null;
+		path.push(key);
+		const resolved = getPath(parent, path);
+		if (resolved) checkPathKey(parent.type, key, parent.options.enablePatches.pathAsArray);
+		return resolved;
+	}
+	path.reverse();
+	return path;
+}
+function getType(target) {
+	if (Array.isArray(target)) return 1;
+	if (target instanceof Map) return 2;
+	if (target instanceof Set) return 3;
+	return 0;
+}
+function get(target, key) {
+	return getType(target) === 2 ? target.get(key) : target[key];
+}
+function set(target, key, value) {
+	if (getType(target) === 2) target.set(key, value);
+	else target[key] = value;
+}
+function isEqual(x, y) {
+	if (x === y) return x !== 0 || 1 / x === 1 / y;
+	else return x !== x && y !== y;
+}
+function revokeProxy(finalities) {
+	const revoke = finalities.revoke;
+	while (revoke.length > 0) revoke.pop()();
+}
+function escapePath(path, pathAsArray) {
+	return pathAsArray ? path : [""].concat(path).map((_item) => {
+		const item = `${_item}`;
+		if (item.indexOf("/") === -1 && item.indexOf("~") === -1) return item;
+		return item.replace(/~/g, "~0").replace(/\//g, "~1");
+	}).join("/");
+}
+function unescapePath(path) {
+	if (Array.isArray(path)) return path;
+	return path.split("/").map((_item) => _item.replace(/~1/g, "/").replace(/~0/g, "~")).slice(1);
+}
+
+//#endregion
+//#region src/utils/proto.ts
+function has(target, key) {
+	return target instanceof Map ? target.has(key) : Object.prototype.hasOwnProperty.call(target, key);
+}
+function getDescriptor(target, key) {
+	if (key in target) {
+		let prototype = Reflect.getPrototypeOf(target);
+		while (prototype) {
+			const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+			if (descriptor) return descriptor;
+			prototype = Reflect.getPrototypeOf(prototype);
+		}
+	}
+}
+/**
+* Whether `concat` and the array methods treat `array` like any array: no
+* subclass, and no own `constructor` or `Symbol.isConcatSpreadable` that
+* changes what `concat` creates.
+*/
+function isPlainArray(array) {
+	return !Object.prototype.hasOwnProperty.call(array, "constructor") && !Object.prototype.hasOwnProperty.call(array, Symbol.isConcatSpreadable) && Object.getPrototypeOf(array) === Array.prototype;
+}
+function isBaseSetInstance(obj) {
+	return Object.getPrototypeOf(obj) === Set.prototype;
+}
+function isBaseMapInstance(obj) {
+	return Object.getPrototypeOf(obj) === Map.prototype;
+}
+
+//#endregion
+//#region src/error.ts
+const errors = [
+	() => `Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`,
+	() => `Map/Set draft does not support any property assignment.`,
+	() => `Only supports setting array indices and the 'length' property.`,
+	() => `Cannot call 'setPrototypeOf()' on drafts`,
+	() => `Cannot call 'defineProperty()' on drafts`,
+	() => `Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`,
+	() => `Cannot return a modified child draft.`,
+	(target) => `current() is only used for Draft, parameter: ${target}`,
+	() => `Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.`,
+	(markResult) => `Unsupported mark result: ${markResult}`,
+	() => `Please check mark() to ensure that it is a stable marker draftable function.`,
+	() => `Cannot modify frozen object`,
+	void 0,
+	() => `Patching reserved attributes like __proto__ and constructor is not allowed.`,
+	(path) => `Cannot apply patch at '${path.join("/")}'.`,
+	() => `Cannot apply replace patch to set.`,
+	(op) => `Unsupported patch operation: ${op}.`,
+	() => `Cannot apply patches with options to a draft.`,
+	(target) => `original() is only used for a draft, parameter: ${target}`,
+	() => "rawReturn() must be called with a value.",
+	() => "rawReturn() must be called with one argument.",
+	() => "apply() with the mutable option changes the state in place, so a patch cannot replace the root state with another value."
+];
+function die(error, ...args) {
+	throw new Error(errors[error](...args));
+}
+
+//#endregion
+//#region src/utils/copy.ts
+function strictCopy(target) {
+	const copy = Object.create(Object.getPrototypeOf(target));
+	Reflect.ownKeys(target).forEach((key) => {
+		let desc = Reflect.getOwnPropertyDescriptor(target, key);
+		if (key !== "__proto__" && desc.enumerable && desc.configurable && desc.writable) {
+			copy[key] = target[key];
+			return;
+		}
+		if (!desc.writable) {
+			desc.writable = true;
+			desc.configurable = true;
+		}
+		if (desc.get || desc.set) desc = {
+			configurable: true,
+			writable: true,
+			enumerable: desc.enumerable,
+			value: target[key]
+		};
+		Reflect.defineProperty(copy, key, desc);
+	});
+	return copy;
+}
+const propIsEnum = Object.prototype.propertyIsEnumerable;
+/**
+* Plain objects with at most this many own enumerable string keys are copied
+* with object spread, which V8 clones in one step. Wider objects are copied
+* key by key into a dictionary-mode object: a map transition per key is far
+* slower there, and whether V8 stays in fast mode depends on transitions that
+* other code may have created for the same key sequence.
+*/
+const SPREAD_KEY_LIMIT = 128;
+function copyPlainObject(original) {
+	const keys = Object.keys(original);
+	if (keys.length <= SPREAD_KEY_LIMIT) return { ...original };
+	const copy = {};
+	copy.a = 1;
+	copy.b = 1;
+	delete copy.a;
+	delete copy.b;
+	for (let index = 0; index < keys.length; index += 1) {
+		const key = keys[index];
+		if (key === "__proto__") Object.defineProperty(copy, key, {
+			value: original[key],
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
+		else copy[key] = original[key];
+	}
+	const symbols = Object.getOwnPropertySymbols(original);
+	for (let index = 0; index < symbols.length; index += 1) {
+		const key = symbols[index];
+		if (propIsEnum.call(original, key)) copy[key] = original[key];
+	}
+	return copy;
+}
+function concatCopy(original) {
+	const copy = Array.prototype.concat.call(original);
+	return copy.length === 1 && copy[0] === original ? Array.prototype.slice.call(original) : copy;
+}
+const arrayValues = Array.prototype[Symbol.iterator];
+const arrayIterator = Object.getPrototypeOf(arrayValues.call([]));
+const arrayIteratorNext = arrayIterator.next;
+/**
+* `concat` leaves V8's fast path for frozen, sealed and non-extensible arrays
+* and takes about ten times as long as a spread there. A spread copies a
+* plain array the same way when it has no holes and none of the iterators it
+* calls has been replaced. Holes read as `undefined`, so arrays that hold
+* `undefined` keep `concat`.
+*/
+function copyLockedArray(original) {
+	return isPlainArray(original) && !Object.prototype.hasOwnProperty.call(original, Symbol.iterator) && Array.prototype[Symbol.iterator] === arrayValues && arrayIterator.next === arrayIteratorNext && !Array.prototype.includes.call(original, void 0) ? [...original] : concatCopy(original);
+}
+function shallowCopy(original, options) {
+	let markResult;
+	if (Array.isArray(original)) return (options === null || options === void 0 ? void 0 : options.enableAutoFreeze) && !Object.isExtensible(original) ? copyLockedArray(original) : concatCopy(original);
+	else if (original instanceof Set) {
+		if (!isBaseSetInstance(original)) {
+			const SubClass = Object.getPrototypeOf(original).constructor;
+			const copy = new SubClass(original.values());
+			Set.prototype.clear.call(copy);
+			for (const item of iterateSet(original)) Set.prototype.add.call(copy, item);
+			return copy;
+		}
+		return !isDraft(original) && Set.prototype.difference ? Set.prototype.difference.call(original, /* @__PURE__ */ new Set()) : new Set(original.values());
+	} else if (original instanceof Map) {
+		if (!isBaseMapInstance(original)) {
+			const SubClass = Object.getPrototypeOf(original).constructor;
+			return new SubClass(original);
+		}
+		return new Map(original);
+	} else if ((options === null || options === void 0 ? void 0 : options.mark) && (markResult = options.mark(original, dataTypes), markResult !== void 0) && markResult !== dataTypes.mutable) {
+		if (markResult === dataTypes.immutable) return strictCopy(original);
+		else if (typeof markResult === "function") {
+			if (options.enablePatches || options.enableAutoFreeze) throw new Error(`You can't use mark and patches or auto freeze together.`);
+			return markResult();
+		}
+		die(9, markResult);
+	} else if (typeof original === "object" && Object.getPrototypeOf(original) === Object.prototype) return copyPlainObject(original);
+	else die(10);
+}
+function ensureShallowCopy(target) {
+	if (target.copy) return;
+	target.copy = shallowCopy(target.original, target.options);
+}
+function deepClone(target) {
+	if (!isDraftable(target)) return getValue(target);
+	if (Array.isArray(target)) return target.map(deepClone);
+	if (target instanceof Map) {
+		const iterable = Array.from(target.entries()).map(([k, v]) => [k, deepClone(v)]);
+		if (!isBaseMapInstance(target)) {
+			const SubClass = Object.getPrototypeOf(target).constructor;
+			return new SubClass(iterable);
+		}
+		return new Map(iterable);
+	}
+	if (target instanceof Set) {
+		const iterable = Array.from(target).map(deepClone);
+		if (!isBaseSetInstance(target)) {
+			const SubClass = Object.getPrototypeOf(target).constructor;
+			return new SubClass(iterable);
+		}
+		return new Set(iterable);
+	}
+	const copy = { ...target };
+	for (const key in copy) {
+		const value = copy[key];
+		if (typeof value === "object" && value !== null) copy[key] = deepClone(value);
+	}
+	const symbols = Object.getOwnPropertySymbols(copy);
+	for (let index = 0; index < symbols.length; index += 1) {
+		const value = copy[symbols[index]];
+		if (typeof value === "object" && value !== null) copy[symbols[index]] = deepClone(value);
+	}
+	return copy;
+}
+
+//#endregion
+//#region src/utils/mark.ts
+function markChanged(proxyDraft) {
+	var _a;
+	proxyDraft.assignedMap = (_a = proxyDraft.assignedMap) !== null && _a !== void 0 ? _a : /* @__PURE__ */ new Map();
+	if (!proxyDraft.operated) {
+		proxyDraft.operated = true;
+		if (proxyDraft.parent) markChanged(proxyDraft.parent);
+	}
+}
+
+//#endregion
+//#region src/utils/deepFreeze.ts
+function throwFrozenError() {
+	die(11);
+}
+function isFreezable(value) {
+	return true;
+}
+function deepFreeze(target, subKey, stack, keys) {
+	stack = stack !== null && stack !== void 0 ? stack : [];
+	keys = keys !== null && keys !== void 0 ? keys : [];
+	if (stack.length > 0) {
+		const index = stack.indexOf(target);
+		if (target && typeof target === "object" && index !== -1) {
+			if (stack[0] === target) throw new Error(`Forbids circular reference`);
+			throw new Error(`Forbids circular reference: ~/${keys.slice(0, index).map((key, index) => {
+				if (typeof key === "symbol") return `[${key.toString()}]`;
+				const parent = stack[index];
+				if (typeof key === "object" && (parent instanceof Map || parent instanceof Set)) return Array.from(parent.keys()).indexOf(key);
+				return key;
+			}).join("/")}`);
+		}
+		stack.push(target);
+		keys.push(subKey);
+	} else stack.push(target);
+	if (Object.isFrozen(target) || isDraft(target)) {
+		stack.pop();
+		keys.pop();
+		return;
+	}
+	switch (getType(target)) {
+		case 2:
+			target.set = target.clear = target.delete = throwFrozenError;
+			Object.freeze(target);
+			for (const [key, value] of target) {
+				if (isFreezable(key)) deepFreeze(key, key, stack, keys);
+				if (isFreezable(value)) deepFreeze(value, key, stack, keys);
+			}
+			break;
+		case 3:
+			target.add = target.clear = target.delete = throwFrozenError;
+			Object.freeze(target);
+			for (const value of target) if (isFreezable(value)) deepFreeze(value, value, stack, keys);
+			break;
+		case 1:
+			Object.freeze(target);
+			let index = 0;
+			for (const value of target) {
+				if (isFreezable(value)) deepFreeze(value, index, stack, keys);
+				index += 1;
+			}
+			break;
+		default:
+			Object.freeze(target);
+			Object.keys(target).forEach((name) => {
+				const value = target[name];
+				if (isFreezable(value)) deepFreeze(value, name, stack, keys);
+			});
+	}
+	stack.pop();
+	keys.pop();
+}
+
+//#endregion
+//#region src/utils/forEach.ts
+function forEach(target, iter) {
+	const type = getType(target);
+	if (type === 0) Reflect.ownKeys(target).forEach((key) => {
+		iter(key, target[key], target);
+	});
+	else if (type === 1) {
+		let index = 0;
+		for (const entry of target) {
+			iter(index, entry, target);
+			index += 1;
+		}
+	} else target.forEach((entry, index) => iter(index, entry, target));
+}
+
+//#endregion
+//#region src/utils/finalize.ts
+function handleValue(target, handledSet, options) {
+	if (isDraft(target) || !isDraftable(target, options) || handledSet.has(target) || Object.isFrozen(target)) return;
+	const isSet = target instanceof Set;
+	const setMap = isSet ? /* @__PURE__ */ new Map() : void 0;
+	handledSet.add(target);
+	forEach(target, (key, value) => {
+		var _a;
+		if (isDraft(value)) {
+			const proxyDraft = getProxyDraft(value);
+			const updatedValue = ((_a = proxyDraft.assignedMap) === null || _a === void 0 ? void 0 : _a.size) || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+			set(isSet ? setMap : target, key, updatedValue);
+		} else handleValue(value, handledSet, options);
+	});
+	if (setMap) {
+		const set = target;
+		const values = Array.from(set);
+		set.clear();
+		values.forEach((value) => {
+			set.add(setMap.has(value) ? setMap.get(value) : value);
+		});
+	}
+}
+function finalizeAssigned(proxyDraft, key) {
+	const copy = proxyDraft.type === 3 ? proxyDraft.setMap : proxyDraft.copy;
+	if (proxyDraft.finalities.revoke.length > 1 && proxyDraft.assignedMap.get(key) && copy) handleValue(get(copy, key), proxyDraft.finalities.handledSet, proxyDraft.options);
+}
+function finalizeSetValue(target, again) {
+	const setMap = target.setMap;
+	if (!setMap || !target.operated) return;
+	let items = setMap.items;
+	if (!items) {
+		if (again) return;
+		let differs = target.assignedMap.size === 0;
+		if (!differs) {
+			for (const [item, value] of setMap) if (getValue(value) !== item) {
+				differs = true;
+				break;
+			}
+		}
+		if (!differs) return;
+		items = setMap.items = Array.from(iterateSet(target.copy));
+	}
+	const copy = target.copy;
+	copy.clear();
+	items.forEach((item) => {
+		const value = setMap.get(item);
+		copy.add(value === void 0 ? item : getValue(value));
+	});
+}
+function finalizePatches(target, generatePatches, patches, inversePatches) {
+	if (target.operated && (target.arrayState !== null && target.arrayState.relocated || target.assignedMap !== void 0 && target.assignedMap.size > 0) && !target.finalized) {
+		if (patches && inversePatches) {
+			const basePath = getPath(target);
+			if (basePath) generatePatches(target, basePath, patches, inversePatches);
+		}
+		target.finalized = true;
+	}
+}
+/**
+* Finalize one draft node: write the final value back into the parent's copy,
+* generate its patches and run callbacks registered for it, for example
+* because it was assigned to another location.
+*/
+function finalizeNode(node, generatePatches, patches, inversePatches) {
+	const parent = node.parent;
+	if (parent) {
+		const parentType = parent.type;
+		const copy = parentType === 3 ? parent.setMap : parent.copy;
+		const key = node.key;
+		const isMapLike = parentType === 3 || parentType === 2;
+		const draft = isMapLike ? copy.get(key) : copy[key];
+		const proxyDraft = draft === node.proxy ? node : getProxyDraft(draft);
+		if (proxyDraft !== node) finalizeSetValue(node);
+		if (proxyDraft) {
+			const updatedValue = proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+			if (proxyDraft.finalities === node.finalities) finalizeSetValue(proxyDraft);
+			finalizePatches(proxyDraft, generatePatches, patches, inversePatches);
+			if (isMapLike) copy.set(key, updatedValue);
+			else copy[key] = updatedValue;
+		}
+	} else {
+		finalizeSetValue(node);
+		finalizePatches(node, generatePatches, patches, inversePatches);
+	}
+	const callbacks = node.callbacks;
+	if (callbacks) for (let index = 0; index < callbacks.length; index += 1) callbacks[index](patches, inversePatches);
+}
+function markFinalization(target, key, value) {
+	const proxyDraft = getProxyDraft(value);
+	if (proxyDraft) {
+		if (!proxyDraft.callbacks) proxyDraft.callbacks = [];
+		proxyDraft.callbacks.push(() => {
+			const copy = target.type === 3 ? target.setMap : target.copy;
+			if (isEqual(get(copy, key), value)) {
+				const updatedValue = proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+				if (proxyDraft.finalities !== target.finalities) finalizeSetValue(target, true);
+				set(copy, key, updatedValue);
+			}
+		});
+		if (target.options.enableAutoFreeze) {
+			if (proxyDraft.finalities !== target.finalities) target.options.enableAutoFreeze = false;
+		}
+	} else if (isDraftable(value, target.options)) target.finalities.draft.push(() => {
+		const copy = target.type === 3 ? target.setMap : target.copy;
+		if (isEqual(get(copy, key), value)) finalizeAssigned(target, key);
+	});
+}
+
+//#endregion
+//#region src/unsafe.ts
+let readable = false;
+const checkReadable = (value, options, ignoreCheckDraftable = false) => {
+	if (typeof value === "object" && value !== null && (!isDraftable(value, options) || ignoreCheckDraftable) && !readable) die(8);
+};
+const checksReads = (options) => !!options.strict && !readable;
+/**
+* `unsafe(callback)` to access mutable data directly in strict mode.
+*
+* ## Example
+*
+* ```ts
+* import { create, unsafe } from 'mutative';
+*
+* class Foobar {
+*   bar = 1;
+* }
+*
+* const baseState = { foobar: new Foobar() };
+* const state = create(
+*   baseState,
+*   (draft) => {
+*    unsafe(() => {
+*      draft.foobar.bar = 2;
+*    });
+*   },
+*   {
+*     strict: true,
+*   }
+* );
+*
+* expect(state).toBe(baseState);
+* expect(state.foobar).toBe(baseState.foobar);
+* expect(state.foobar.bar).toBe(2);
+* ```
+*/
+function unsafe(callback) {
+	const previous = readable;
+	readable = true;
+	try {
+		return callback();
+	} finally {
+		readable = previous;
+	}
+}
+
+//#endregion
+//#region src/map.ts
+function getEntry(target, key) {
+	var _a, _b;
+	const value = latest(target).get(key);
+	const mutable = ((_b = (_a = target.options).mark) === null || _b === void 0 ? void 0 : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+	if (target.options.strict) checkReadable(value, target.options, mutable);
+	if (mutable) return value;
+	if (target.finalized || !isDraftable(value, target.options)) return value;
+	if (value !== target.original.get(key)) return value;
+	const draft = internal.createDraft(value, target, key, target.finalities, target.options);
+	ensureShallowCopy(target);
+	target.copy.set(key, draft);
+	return draft;
+}
+const mapHandler = {
+	get size() {
+		return latest(getProxyDraft(this)).size;
+	},
+	has(key) {
+		return latest(getProxyDraft(this)).has(key);
+	},
+	set(key, value) {
+		{
+			let isDraftKey = false;
+			try {
+				isDraftKey = !!getProxyDraft(key);
+			} catch (_a) {}
+			if (isDraftKey) throw new Error(`A draft cannot be a Map key: its producer revokes it when it ends. Use original(key), current(key) or an id as the key; see https://mutative.js.org/docs/extra-topics/faq`);
+		}
+		const target = getProxyDraft(this);
+		const source = latest(target);
+		if (!source.has(key) || !isEqual(source.get(key), value)) {
+			ensureShallowCopy(target);
+			markChanged(target);
+			target.assignedMap.set(key, true);
+			target.copy.set(key, value);
+			markFinalization(target, key, value);
+		}
+		return this;
+	},
+	delete(key) {
+		if (!this.has(key)) return false;
+		const target = getProxyDraft(this);
+		ensureShallowCopy(target);
+		markChanged(target);
+		if (target.original.has(key)) target.assignedMap.set(key, false);
+		else target.assignedMap.delete(key);
+		target.copy.delete(key);
+		return true;
+	},
+	clear() {
+		const target = getProxyDraft(this);
+		if (!this.size) return;
+		ensureShallowCopy(target);
+		markChanged(target);
+		target.assignedMap = /* @__PURE__ */ new Map();
+		for (const [key] of target.original) target.assignedMap.set(key, false);
+		target.copy.clear();
+	},
+	forEach(callback, thisArg) {
+		const target = getProxyDraft(this);
+		latest(target).forEach((_value, key) => {
+			assertDraftActive(target);
+			callback.call(thisArg, getEntry(target, key), key, this);
+		});
+	},
+	get(key) {
+		return getEntry(getProxyDraft(this), key);
+	},
+	keys() {
+		return latest(getProxyDraft(this)).keys();
+	},
+	values() {
+		const target = getProxyDraft(this);
+		const iterator = this.keys();
+		return {
+			__proto__: iteratorPrototype,
+			next: () => {
+				const result = iterator.next();
+				if (result.done) return result;
+				assertDraftActive(target);
+				return {
+					done: false,
+					value: getEntry(target, result.value)
+				};
+			}
+		};
+	},
+	entries() {
+		const target = getProxyDraft(this);
+		const iterator = this.keys();
+		return {
+			__proto__: iteratorPrototype,
+			next: () => {
+				const result = iterator.next();
+				if (result.done) return result;
+				assertDraftActive(target);
+				return {
+					done: false,
+					value: [result.value, getEntry(target, result.value)]
+				};
+			}
+		};
+	},
+	[iteratorSymbol]() {
+		return this.entries();
+	}
+};
+const mapHandlerKeys = Reflect.ownKeys(mapHandler);
+
+//#endregion
+//#region src/set.ts
+const getNextIterator = (target, iterator, isValuesIterator) => () => {
+	var _a, _b;
+	const result = iterator.next();
+	if (result.done) return result;
+	assertDraftActive(target);
+	const key = result.value;
+	let value = setItemValue(target, key);
+	const currentDraft = getProxyDraft(value);
+	const mutable = ((_b = (_a = target.options).mark) === null || _b === void 0 ? void 0 : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+	if (target.options.strict) checkReadable(key, target.options, mutable);
+	if (!mutable && !currentDraft && value === key && isDraftable(key, target.options) && !target.finalized && target.original.has(key)) {
+		const proxy = internal.createDraft(key, target, key, target.finalities, target.options);
+		getSetMap(target).set(key, proxy);
+		value = proxy;
+	} else if (currentDraft) value = currentDraft.proxy;
+	return {
+		done: false,
+		value: isValuesIterator ? value : [value, value]
+	};
+};
+const setHandler = {
+	get size() {
+		return latest(getProxyDraft(this)).size;
+	},
+	has(value) {
+		const items = latest(getProxyDraft(this));
+		let valueProxyDraft;
+		return items.has(value) || !!(valueProxyDraft = getProxyDraft(value)) && items.has(valueProxyDraft.original);
+	},
+	add(value) {
+		const target = getProxyDraft(this);
+		if (!this.has(value)) {
+			ensureShallowCopy(target);
+			markChanged(target);
+			target.assignedMap.set(value, true);
+			target.copy.add(value);
+			if (value && typeof value === "object") getSetMap(target).set(value, value);
+			markFinalization(target, value, value);
+		}
+		return this;
+	},
+	delete(value) {
+		if (!this.has(value)) return false;
+		const target = getProxyDraft(this);
+		ensureShallowCopy(target);
+		markChanged(target);
+		const copy = target.copy;
+		const valueProxyDraft = getProxyDraft(value);
+		const item = valueProxyDraft && copy.has(valueProxyDraft.original) ? valueProxyDraft.original : value;
+		if (valueProxyDraft && item === value) target.assignedMap.delete(value);
+		else target.assignedMap.set(item, false);
+		if (target.setMap) target.setMap.delete(item);
+		return copy.delete(item);
+	},
+	clear() {
+		if (!this.size) return;
+		const target = getProxyDraft(this);
+		ensureShallowCopy(target);
+		markChanged(target);
+		for (const value of target.original) target.assignedMap.set(value, false);
+		if (target.setMap) target.setMap.clear();
+		target.copy.clear();
+	},
+	values() {
+		const target = getProxyDraft(this);
+		ensureShallowCopy(target);
+		const iterator = iterateSet(target.copy);
+		return {
+			__proto__: iteratorPrototype,
+			next: getNextIterator(target, iterator, true)
+		};
+	},
+	entries() {
+		const target = getProxyDraft(this);
+		ensureShallowCopy(target);
+		const iterator = iterateSet(target.copy);
+		return {
+			__proto__: iteratorPrototype,
+			next: getNextIterator(target, iterator, false)
+		};
+	},
+	keys() {
+		return this.values();
+	},
+	[iteratorSymbol]() {
+		return this.values();
+	},
+	forEach(callback, thisArg) {
+		const iterator = this.values();
+		let result = iterator.next();
+		while (!result.done) {
+			callback.call(thisArg, result.value, result.value, this);
+			result = iterator.next();
+		}
+	}
+};
+if ("difference" in Set.prototype) [
+	"intersection",
+	"union",
+	"difference",
+	"symmetricDifference",
+	"isSubsetOf",
+	"isSupersetOf",
+	"isDisjointFrom"
+].forEach((method) => {
+	setHandler[method] = function(other) {
+		return Set.prototype[method].call(new Set(this.values()), other);
+	};
+});
+const setHandlerKeys = Reflect.ownKeys(setHandler);
+
+//#endregion
+//#region src/array.ts
+const arrayProto = Array.prototype;
+const arrayIncludes = arrayProto.includes;
+const hasOwn$2 = Object.prototype.hasOwnProperty;
+let recentProxy = null;
+let recentRevoke = null;
+const arrayProxies = /* @__PURE__ */ new WeakSet();
+/**
+* Records that the get trap handed out an optimized method of `target`. Only
+* a switch between arrays of a live producer adds a weak-collection entry, so
+* the common case of one array per producer allocates nothing.
+*/
+function trackArrayMethod(target) {
+	const proxy = target.proxy;
+	if (proxy !== recentProxy) {
+		if (recentRevoke !== null && recentRevoke.length > 0) arrayProxies.add(recentProxy);
+		if (target.finalities.scoped) {
+			recentProxy = proxy;
+			recentRevoke = target.finalities.revoke;
+		} else {
+			arrayProxies.add(proxy);
+			recentProxy = null;
+			recentRevoke = null;
+		}
+	}
+}
+/**
+* Called by `create` whenever a producer ends, normally or by an error, so
+* this module keeps no reference to its drafts. Another producer's entry, such
+* as an outer producer's, is left in place.
+*/
+function releaseArrayMethods(revoke) {
+	if (recentRevoke === revoke) {
+		recentProxy = null;
+		recentRevoke = null;
+	}
+}
+function canExecute(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+/**
+* The array draft behind `this` when a method may run natively on its copy:
+* plain arrays only, outside `current()` and without a custom mark.
+*/
+function nativeState(self) {
+	if (self !== recentProxy && !arrayProxies.has(self)) return null;
+	const target = self[PROXY_DRAFT];
+	return !target.finalized && !target.options.mark && isPlainArray(target.original) ? target : null;
+}
+const toInteger = (value) => Math.trunc(+value) || 0;
+function relativeIndex(value, length, fallback) {
+	if (value === void 0) return fallback;
+	const integer = toInteger(value);
+	return integer < 0 ? Math.max(length + integer, 0) : Math.min(integer, length);
+}
+function arrayState(target) {
+	var _a;
+	return (_a = target.arrayState) !== null && _a !== void 0 ? _a : target.arrayState = {
+		relocated: false,
+		diffStart: 0,
+		diffEnd: 0,
+		baseRefs: null,
+		delta: 0,
+		lookups: 0,
+		inert: null,
+		dense: null
+	};
+}
+function hasHoles(array) {
+	if (!arrayIncludes.call(array, void 0)) return false;
+	for (let index = 0; index < array.length; index += 1) if (!(index in array)) return true;
+	return false;
+}
+function isDense(target) {
+	const state = arrayState(target);
+	let dense = state.dense;
+	if (dense === null) dense = state.dense = !hasHoles(latest(target));
+	return dense;
+}
+function baseIndices(target) {
+	const state = arrayState(target);
+	let indices = state.baseRefs;
+	if (indices === null) {
+		indices = state.baseRefs = /* @__PURE__ */ new Map();
+		const original = target.original;
+		for (let index = 0; index < original.length; index += 1) indices.set(original[index], index);
+	}
+	return indices;
+}
+/**
+* The original index of `value`, found at `index` once elements have moved
+* natively, or undefined when it is not an element of the original array. The
+* first few lookups find the index the map of original indices holds for a
+* repeated element without indexing the array; later ones build the map.
+*/
+function baseIndexOf(target, value, index) {
+	const state = arrayState(target);
+	if (state.baseRefs === null && state.lookups < 8) {
+		state.lookups += 1;
+		const original = target.original;
+		let found = +index + state.delta;
+		if (!(found >= 0 && original[found] === value)) {
+			found = arrayProto.lastIndexOf.call(original, value);
+			return found === -1 ? void 0 : found;
+		}
+		let step = 1;
+		for (let next, copies = 0; (next = arrayProto.indexOf.call(original, value, found + step)) !== -1;) {
+			found = next;
+			if (++copies > 16) step *= 2;
+		}
+		return step > 1 ? arrayProto.lastIndexOf.call(original, value, found + step - 1) : found;
+	}
+	return baseIndices(target).get(value);
+}
+/**
+* The original index under which a read of `value` at `index` drafts it, or
+* -1 when the read hands it out as is: an element at its original index, or,
+* once native operations moved elements, any element of the original array
+* except a value the recipe assigned at `index`, whose record moves along
+* with it. Reads, searches and removals all decide by it.
+*/
+function baseIndex(target, value, index) {
+	if (target.original[index] === value) return index;
+	const state = target.arrayState;
+	if (state === null || !state.relocated || target.assignedMap.get(String(index))) return -1;
+	const found = baseIndexOf(target, value, index);
+	return found === void 0 ? -1 : found;
+}
+function childAt(target, index) {
+	var _a;
+	return target.child !== null && target.childKey === String(index) ? target.child : (_a = target.children) === null || _a === void 0 ? void 0 : _a[index];
+}
+function registerChild(target, index, draft) {
+	var _a;
+	if (target.child === null) {
+		target.child = draft;
+		target.childKey = String(index);
+	} else ((_a = target.children) !== null && _a !== void 0 ? _a : target.children = [])[index] = draft;
+}
+function registerAssigned(target, index, value) {
+	const key = String(index);
+	const state = target.arrayState;
+	if (state !== null && canExecute(value)) state.inert = null;
+	const original = target.original;
+	if (hasOwn$2.call(original, index) && isEqual(value, original[index])) return;
+	target.assignedMap.set(key, true);
+	if (typeof value === "object" && value !== null) markFinalization(target, key, value);
+}
+function isInert(target) {
+	const state = arrayState(target);
+	let inert = state.inert;
+	if (inert === null) {
+		const source = latest(target);
+		inert = true;
+		for (let index = 0; index < source.length; index += 1) if (canExecute(source[index])) {
+			inert = false;
+			break;
+		}
+		state.inert = inert;
+	}
+	return inert;
+}
+function markRange(target, from, to) {
+	const state = arrayState(target);
+	if (state.diffEnd > state.diffStart) {
+		state.diffStart = Math.min(state.diffStart, from);
+		state.diffEnd = Math.max(state.diffEnd, to);
+	} else {
+		state.diffStart = from;
+		state.diffEnd = to;
+	}
+	state.relocated = true;
+}
+/**
+* After the proxy lengthened an array draft, by its length or by an assignment
+* past its end, holes follow. An index that the array exposes again below the
+* original length lost its element to a shorter length earlier; no assignment
+* records such an index, and a native move may have dropped one, so patches
+* compare it. Marking the range as moved leaves reads as they are: an exposed
+* index holds a hole, and an assigned value is handed out as it is.
+*/
+function resized(target, previous) {
+	const state = target.arrayState;
+	if (state !== null) state.dense = null;
+	const end = Math.min(target.copy.length, target.original.length);
+	if (previous < end) markRange(target, previous, end);
+}
+/**
+* After a native operation moved elements: drafts created here take their
+* new keys, assigned values are registered again at their new indices, and
+* the array remembers that identity against the original index can no longer
+* tell a moved base element from an assigned value.
+*/
+function relocate(target, map, from, to, delta) {
+	var _a;
+	markRange(target, from, to);
+	target.arrayState.delta = delta;
+	const copy = target.copy;
+	const entries = [];
+	if (target.child !== null) entries.push([Number(target.childKey), target.child]);
+	(_a = target.children) === null || _a === void 0 || _a.forEach((draft, index) => {
+		entries.push([index, draft]);
+	});
+	target.child = null;
+	target.childKey = null;
+	target.children = void 0;
+	for (let position = 0; position < entries.length; position += 1) {
+		const [index, draft] = entries[position];
+		const next = map(index);
+		if (next >= 0) {
+			registerChild(target, next, draft);
+			if (next !== index) markFinalization(target, String(next), draft);
+		}
+	}
+	const assignedMap = target.assignedMap;
+	const assigned = [];
+	assignedMap.forEach((flag, key) => {
+		if (key !== "length") assigned.push([key, flag]);
+	});
+	for (let position = 0; position < assigned.length; position += 1) assignedMap.delete(assigned[position][0]);
+	for (let position = 0; position < assigned.length; position += 1) {
+		const [key, flag] = assigned[position];
+		const index = Number(key);
+		const next = map(index);
+		if (next >= 0) {
+			if (flag && next !== index) registerAssigned(target, next, copy[next]);
+			else assignedMap.set(String(next), flag);
+		}
+	}
+}
+function removalKey(target, index) {
+	const value = latest(target)[index];
+	if (typeof value !== "object" || value === null) return -1;
+	if (childAt(target, index) === value) return value;
+	return isDraftable(value, target.options) ? baseIndex(target, value, index) : -1;
+}
+function removed(target, value, key) {
+	if (typeof key !== "number") return key;
+	if (key < 0) return value;
+	ensureShallowCopy(target);
+	return internal.createDraft(value, target, key, target.finalities, target.options);
+}
+function prepare(target) {
+	ensureShallowCopy(target);
+	markChanged(target);
+	return target.copy;
+}
+function native(method, impl) {
+	const original = arrayProto[method];
+	return function(...args) {
+		const target = nativeState(this);
+		return target === null || checksReads(target.options) && !isInert(target) ? original.apply(this, args) : impl(target, this, args, original);
+	};
+}
+function isBaseElement(target, value, index) {
+	return childAt(target, index) !== value && baseIndex(target, value, index) !== -1;
+}
+/**
+* Whether `value`, which the array already holds at `index`, is an element of
+* the base state that native methods moved there. The proxy path moves
+* elements by reading them, so it holds a draft there, and assigning the raw
+* element replaces the draft and records an assignment; the set trap records
+* one as well instead of ignoring the assignment.
+*/
+function isMovedElement(target, value, index) {
+	return typeof value === "object" && value !== null && value !== target.original[index] && baseIndex(target, value, index) !== -1;
+}
+function search(method) {
+	const nativeSearch = arrayProto[method];
+	const backwards = method === "lastIndexOf";
+	const find = backwards ? arrayProto.lastIndexOf : arrayProto.indexOf;
+	return native(method, (target, self, args, original) => {
+		const source = latest(target);
+		if (source.length === 0) return method === "includes" ? false : -1;
+		if (canExecute(args[1])) return original.apply(self, args);
+		const value = args[0];
+		if (typeof value !== "object" || value === null) return nativeSearch.apply(source, args);
+		let index = args.length > 1 ? find.call(source, value, args[1]) : find.call(source, value);
+		while (index !== -1) {
+			if (!hasOwn$2.call(source, index)) return original.apply(self, args);
+			if (!isBaseElement(target, value, index)) break;
+			if (!isDense(target)) return original.apply(self, args);
+			if (!isDraftable(value, target.options)) break;
+			index = backwards ? index === 0 ? -1 : find.call(source, value, index - 1) : find.call(source, value, index + 1);
+		}
+		return method === "includes" ? index !== -1 : index;
+	});
+}
+/**
+* Array methods without callbacks run natively on the draft's copy instead
+* of moving every element through the proxy traps.
+*/
+const arrayMethods = Object.assign(Object.create(null), {
+	indexOf: search("indexOf"),
+	lastIndexOf: search("lastIndexOf"),
+	includes: search("includes"),
+	join: native("join", (target, self, args) => arrayProto.join.call(canExecute(args[0]) || !isInert(target) ? self : latest(target), args[0])),
+	shift: native("shift", (target, self, args, original) => {
+		if (latest(target).length === 0) return void 0;
+		if (!isDense(target)) return original.apply(self, args);
+		const key = removalKey(target, 0);
+		const copy = prepare(target);
+		const value = arrayProto.shift.call(copy);
+		relocate(target, (index) => index - 1, 0, copy.length + 1, 1);
+		return removed(target, value, key);
+	}),
+	unshift: native("unshift", (target, self, items, original) => {
+		const count = items.length;
+		if (count === 0) return latest(target).length;
+		if (!isDense(target)) return original.apply(self, items);
+		const copy = prepare(target);
+		arrayProto.unshift.apply(copy, items);
+		relocate(target, (index) => index + count, 0, copy.length, -count);
+		for (let index = 0; index < count; index += 1) registerAssigned(target, index, items[index]);
+		return copy.length;
+	}),
+	splice: native("splice", (target, self, args, original) => {
+		if (canExecute(args[0]) || canExecute(args[1])) return original.apply(self, args);
+		const length = latest(target).length;
+		const start = relativeIndex(args[0], length, 0);
+		const deleteCount = args.length === 0 ? 0 : args.length === 1 ? length - start : Math.min(Math.max(toInteger(args[1]), 0), length - start);
+		const insertCount = Math.max(args.length - 2, 0);
+		if (deleteCount === 0 && insertCount === 0) return original.apply(self, args);
+		const source = latest(target);
+		if (deleteCount === insertCount) {
+			let same = true;
+			for (let index = 0; same && index < insertCount; index += 1) {
+				const at = start + index;
+				const value = source[at];
+				const item = args[index + 2];
+				if (!isEqual(item, value)) {
+					if (typeof value !== "object" || value === null || hasOwn$2.call(source, at) && isBaseElement(target, value, at)) same = false;
+					else if (childAt(target, at) === value) same = isEqual(item, getProxyDraft(value).original);
+					else return original.apply(self, args);
+				}
+			}
+			if (same) return original.apply(self, args);
+		}
+		if (!isDense(target)) return original.apply(self, args);
+		const keys = [];
+		for (let index = 0; index < deleteCount; index += 1) keys.push(removalKey(target, start + index));
+		const copy = prepare(target);
+		const spliceArgs = [start, deleteCount];
+		for (let index = 2; index < args.length; index += 1) spliceArgs.push(args[index]);
+		const values = arrayProto.splice.apply(copy, spliceArgs);
+		relocate(target, (index) => index < start ? index : index < start + deleteCount ? -1 : index - deleteCount + insertCount, start, deleteCount === insertCount ? start + deleteCount : Math.max(length, copy.length), deleteCount - insertCount);
+		for (let index = 0; index < insertCount; index += 1) registerAssigned(target, start + index, args[index + 2]);
+		for (let index = 0; index < values.length; index += 1) values[index] = removed(target, values[index], keys[index]);
+		return values;
+	}),
+	sort: native("sort", (target, self, [compare], original) => {
+		if (compare !== void 0 && typeof compare !== "function" || !isInert(target) || !isDense(target)) return original.call(self, compare);
+		const source = latest(target);
+		const length = source.length;
+		const sorted = new Array(length);
+		for (let index = 0; index < length; index += 1) sorted[index] = source[index];
+		arrayProto.sort.call(sorted, compare);
+		let changed = false;
+		for (let index = 0; index < length; index += 1) if (!isEqual(sorted[index], source[index])) {
+			changed = true;
+			break;
+		}
+		const copy = changed ? prepare(target) : target.copy;
+		if (copy !== null) for (let index = 0; index < length; index += 1) copy[index] = sorted[index];
+		if (changed) markRange(target, 0, length);
+		return self;
+	}),
+	reverse: native("reverse", (target, self, args, original) => {
+		const source = latest(target);
+		const length = source.length;
+		if (length < 2) return self;
+		if (!isDense(target)) return original.apply(self, args);
+		const assigned = target.assignedMap;
+		let changed = assigned !== void 0 && assigned.size > 0;
+		for (let low = 0, high = length - 1; !changed && low < high; low += 1, high -= 1) changed = !isEqual(source[low], source[high]);
+		if (changed) {
+			arrayProto.reverse.call(prepare(target));
+			relocate(target, (index) => length - 1 - index, 0, length);
+		}
+		return self;
+	})
+});
+
+//#endregion
+//#region src/current.ts
+function handleReturnValue(rootDraft, value, useRawReturn) {
+	let containsDraft = false;
+	const skipsFrozen = !!(rootDraft === null || rootDraft === void 0 ? void 0 : rootDraft.options.enableAutoFreeze);
+	const replaceDrafts = (target, frozen) => forEach(target, (key, item, source) => {
+		const proxyDraft = getProxyDraft(item);
+		if (proxyDraft && rootDraft && proxyDraft.finalities === rootDraft.finalities) {
+			if (frozen) throw new Error(`The return value holds a draft in a frozen object or in a value it holds. With auto-freeze, production builds do not search frozen objects for drafts, so do not put drafts there.`);
+			containsDraft = true;
+			const currentValue = proxyDraft.original;
+			if (source instanceof Set) {
+				const arr = Array.from(source);
+				source.clear();
+				arr.forEach((_item) => source.add(key === _item ? currentValue : _item));
+			} else set(source, key, currentValue);
+		} else if (typeof item === "object" && item !== null) {
+			if (!skipsFrozen || !Object.isFrozen(item)) replaceDrafts(item, frozen);
+			else replaceDrafts(item, true);
+		}
+	});
+	if (!skipsFrozen || !Object.isFrozen(value)) replaceDrafts(value);
+	else replaceDrafts(value, true);
+	if (useRawReturn) {
+		if (containsDraft) console.warn(`The return value contains drafts, please don't use 'rawReturn()' to wrap the return value.`);
+	} else if (!containsDraft) console.warn(`The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance.`);
+}
+function getCurrent(target, rootOptions) {
+	var _a;
+	const proxyDraft = getProxyDraft(target);
+	const options = proxyDraft ? proxyDraft.options : rootOptions;
+	if (!isDraftable(target, options)) return target;
+	const type = getType(target);
+	if (proxyDraft && !proxyDraft.operated) return proxyDraft.original;
+	const array = type === 1 && proxyDraft && !checksReads(proxyDraft.options) ? proxyDraft : null;
+	let currentValue;
+	let changed = false;
+	function ensureShallowCopy() {
+		currentValue = type === 2 ? !isBaseMapInstance(target) ? new (Object.getPrototypeOf(target)).constructor(target) : new Map(target) : type === 3 ? proxyDraft ? Array.from(iterateSet(latest(proxyDraft)), (item) => setItemValue(proxyDraft, item)) : Array.from(target) : shallowCopy(array ? latest(array) : target, options);
+	}
+	if (proxyDraft) {
+		proxyDraft.finalized = true;
+		try {
+			ensureShallowCopy();
+		} finally {
+			proxyDraft.finalized = false;
+		}
+	} else if (type === 3) ensureShallowCopy();
+	else currentValue = target;
+	forEach(currentValue, (key, value) => {
+		if (proxyDraft && (isEqual(get(proxyDraft.original, key), value) || array && !isDraft(value) && (typeof value !== "object" || !(array.assignedMap.size && array.assignedMap.get(String(key)))))) return;
+		const newValue = getCurrent(value, options);
+		if (newValue !== value) {
+			changed = true;
+			if (currentValue === target) ensureShallowCopy();
+			set(currentValue, key, newValue);
+		}
+	});
+	if (type === 3) {
+		if (!proxyDraft && !changed) return target;
+		const value = (_a = proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.original) !== null && _a !== void 0 ? _a : target;
+		return !isBaseSetInstance(value) ? new (Object.getPrototypeOf(value)).constructor(currentValue) : new Set(currentValue);
+	}
+	return currentValue;
+}
+function current(target) {
+	if (!isDraft(target)) die(7, target);
+	return getCurrent(target);
+}
+
+//#endregion
+//#region src/patch.ts
+/**
+* Patch values must not contain drafts. A draft that is still present when its
+* container generates patches is represented by its original object when it
+* was not modified, or by a snapshot of its current state otherwise.
+*/
+function cloneIfNeeded(target) {
+	const proxyDraft = getProxyDraft(target);
+	if (!proxyDraft) return target;
+	return proxyDraft.operated ? current(target) : proxyDraft.original;
+}
+const hasOwn$1 = Object.prototype.hasOwnProperty;
+const SPARSE_HOLE_LIMIT = 65536;
+function restoreSuffix(to, start, indices, basePath, result, pathAsArray) {
+	const restore = (index) => result.push({
+		op: Operation.Replace,
+		path: escapePath(basePath.concat([index]), pathAsArray),
+		value: cloneIfNeeded(to[index])
+	});
+	if (indices !== null) {
+		for (let position = 0; position < indices.length; position += 1) {
+			const index = indices[position];
+			if (index >= start && index < to.length && hasOwn$1.call(to, index)) restore(index);
+		}
+		return;
+	}
+	let index = start;
+	let holes = 0;
+	while (index < to.length && holes <= SPARSE_HOLE_LIMIT) {
+		if (hasOwn$1.call(to, index)) restore(index);
+		else holes += 1;
+		index += 1;
+	}
+	if (index === to.length) return;
+	for (const key of Object.getOwnPropertyNames(to)) {
+		const own = Number(key);
+		if (Number.isInteger(own) && own >= index && own < to.length && String(own) === key) restore(own);
+	}
+}
+function rebuildSuffix(from, to, start, indices, basePath, result, pathAsArray, arrayLengthAssignment) {
+	const lengthPath = escapePath(basePath.concat(["length"]), pathAsArray);
+	const cut = Math.min(start, to.length);
+	if (arrayLengthAssignment) {
+		if (from.length > cut) result.push({
+			op: Operation.Replace,
+			path: lengthPath,
+			value: cut
+		});
+	} else for (let index = from.length - 1; index >= cut; index -= 1) result.push({
+		op: Operation.Remove,
+		path: escapePath(basePath.concat([index]), pathAsArray)
+	});
+	if (to.length <= cut) return;
+	result.push({
+		op: Operation.Replace,
+		path: lengthPath,
+		value: to.length
+	});
+	restoreSuffix(to, cut, indices, basePath, result, pathAsArray);
+}
+function generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray) {
+	let { original, assignedMap, options } = proxyState;
+	let copy = proxyState.copy;
+	const { arrayLengthAssignment = true } = options.enablePatches;
+	const shorter = copy.length < original.length;
+	if (shorter) {
+		[original, copy] = [copy, original];
+		[patches, inversePatches] = [inversePatches, patches];
+	}
+	const arrayState = proxyState.arrayState;
+	const diffStart = arrayState === null ? 0 : arrayState.diffStart;
+	const diffEnd = arrayState === null ? 0 : arrayState.diffEnd;
+	const assigned = [];
+	assignedMap.forEach((flag, key) => {
+		if (flag && key !== "length") {
+			const index = Number(key);
+			if (index < diffStart || index >= diffEnd) assigned.push(index);
+		}
+	});
+	assigned.sort((a, b) => a - b);
+	const indices = [];
+	let position = 0;
+	for (; position < assigned.length && assigned[position] < diffStart; position += 1) indices.push(assigned[position]);
+	for (let index = diffStart; index < diffEnd; index += 1) indices.push(index);
+	for (; position < assigned.length; position += 1) indices.push(assigned[position]);
+	let forward = -1;
+	let inverse = -1;
+	for (let position = 0; position < indices.length; position += 1) {
+		const index = indices[position];
+		if (index >= original.length) break;
+		const value = copy[index];
+		const previous = original[index];
+		let inCopy = true;
+		let inOriginal = true;
+		if (value === void 0 || previous === void 0) {
+			inCopy = hasOwn$1.call(copy, index);
+			inOriginal = hasOwn$1.call(original, index);
+		}
+		if (inCopy !== inOriginal || !isEqual(value, previous)) {
+			const _path = basePath.concat([index]);
+			const path = escapePath(_path, pathAsArray);
+			if (forward === -1) {
+				if (inCopy) patches.push({
+					op: Operation.Replace,
+					path,
+					value: cloneIfNeeded(value)
+				});
+				else forward = index;
+			}
+			if (inverse === -1) {
+				if (inOriginal) inversePatches.push({
+					op: Operation.Replace,
+					path,
+					value: cloneIfNeeded(previous)
+				});
+				else inverse = index;
+			}
+			if (forward !== -1 && inverse !== -1) break;
+		}
+	}
+	if (forward === -1) for (let index = original.length; index < copy.length; index += 1) {
+		const value = copy[index];
+		if (value === void 0 && !hasOwn$1.call(copy, index)) {
+			forward = index;
+			break;
+		}
+		const _path = basePath.concat([index]);
+		const path = escapePath(_path, pathAsArray);
+		patches.push({
+			op: Operation.Add,
+			path,
+			value: cloneIfNeeded(value)
+		});
+	}
+	if (forward !== -1) rebuildSuffix(original, copy, forward, shorter || forward < original.length ? null : indices, basePath, patches, pathAsArray, arrayLengthAssignment);
+	if (inverse !== -1) rebuildSuffix(copy, original, inverse, null, basePath, inversePatches, pathAsArray, arrayLengthAssignment);
+	else if (original.length < copy.length) {
+		if (arrayLengthAssignment) {
+			const _path = basePath.concat(["length"]);
+			const path = escapePath(_path, pathAsArray);
+			inversePatches.push({
+				op: Operation.Replace,
+				path,
+				value: original.length
+			});
+		} else for (let index = copy.length; original.length < index; index -= 1) {
+			const _path = basePath.concat([index - 1]);
+			const path = escapePath(_path, pathAsArray);
+			inversePatches.push({
+				op: Operation.Remove,
+				path
+			});
+		}
+	}
+}
+function generatePatchesFromAssigned({ original, copy, assignedMap }, basePath, patches, inversePatches, pathAsArray) {
+	assignedMap.forEach((assignedValue, key) => {
+		const originalValue = get(original, key);
+		const value = cloneIfNeeded(get(copy, key));
+		const op = !assignedValue ? Operation.Remove : has(original, key) ? Operation.Replace : Operation.Add;
+		if (isEqual(originalValue, value) && op === Operation.Replace) return;
+		checkPathKey(getType(original), key, pathAsArray);
+		const _path = basePath.concat([key]);
+		const path = escapePath(_path, pathAsArray);
+		patches.push(op === Operation.Remove ? {
+			op,
+			path
+		} : {
+			op,
+			path,
+			value
+		});
+		inversePatches.push(op === Operation.Add ? {
+			op: Operation.Remove,
+			path
+		} : op === Operation.Remove ? {
+			op: Operation.Add,
+			path,
+			value: originalValue
+		} : {
+			op: Operation.Replace,
+			path,
+			value: originalValue
+		});
+	});
+}
+function generateSetPatches({ original, copy }, basePath, patches, inversePatches, pathAsArray) {
+	let index = 0;
+	original.forEach((value) => {
+		if (!copy.has(value)) {
+			const _path = basePath.concat([index]);
+			const path = escapePath(_path, pathAsArray);
+			patches.push({
+				op: Operation.Remove,
+				path,
+				value
+			});
+			inversePatches.unshift({
+				op: Operation.Add,
+				path,
+				value
+			});
+		}
+		index += 1;
+	});
+	index = 0;
+	copy.forEach((value) => {
+		if (!original.has(value)) {
+			const _path = basePath.concat([index]);
+			const path = escapePath(_path, pathAsArray);
+			patches.push({
+				op: Operation.Add,
+				path,
+				value
+			});
+			inversePatches.unshift({
+				op: Operation.Remove,
+				path,
+				value
+			});
+		}
+		index += 1;
+	});
+}
+function generatePatches(proxyState, basePath, patches, inversePatches) {
+	const { pathAsArray = true } = proxyState.options.enablePatches;
+	switch (proxyState.type) {
+		case 0:
+		case 2: return generatePatchesFromAssigned(proxyState, basePath, patches, inversePatches, pathAsArray);
+		case 1: return generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+		case 3: return generateSetPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+	}
+}
+
+//#endregion
+//#region src/draft.ts
+/**
+* Accepts the keys the array set trap has always accepted: canonical
+* non-negative integer strings via an allocation-free scan, and other
+* spellings such as '-0' via the original numeric round trip.
+*/
+function isArrayIndexKey(key) {
+	if (typeof key === "string" && key.length < 16) {
+		let index = 0;
+		while (index < key.length) {
+			const code = key.charCodeAt(index);
+			if (code < 48 || code > 57) break;
+			index += 1;
+		}
+		if (index > 0 && index === key.length && (index === 1 || key.charCodeAt(0) !== 48)) return true;
+	}
+	let _key;
+	return Number.isInteger(_key = Number(key)) && _key >= 0 && (key === 0 || _key === 0 || String(_key) === String(key));
+}
+const hasOwn = Object.prototype.hasOwnProperty;
+function getTrap(target, key, receiver) {
+	var _a, _b, _c;
+	if (key === PROXY_DRAFT) return target;
+	const { options, type } = target;
+	const source = latest(target);
+	let markResult;
+	if (options.mark) {
+		const value = key === "size" && (source instanceof Map || source instanceof Set) ? Reflect.get(source, key) : Reflect.get(source, key, receiver);
+		markResult = options.mark(value, dataTypes);
+		if (markResult === dataTypes.mutable) {
+			if (options.strict) checkReadable(value, options, true);
+			return value;
+		}
+	}
+	if (type === 2) {
+		if (mapHandlerKeys.includes(key)) {
+			if (key === "size") return Object.getOwnPropertyDescriptor(mapHandler, "size").get.call(target.proxy);
+			return mapHandler[key].bind(target.proxy);
+		}
+	} else if (type === 3) {
+		if (setHandlerKeys.includes(key)) {
+			if (key === "size") return Object.getOwnPropertyDescriptor(setHandler, "size").get.call(target.proxy);
+			return setHandler[key].bind(target.proxy);
+		}
+	}
+	if (type === 2 ? !source.has(key) : !hasOwn.call(source, key)) {
+		if (type === 1 && Object.getPrototypeOf(target.original) === Array.prototype) {
+			const method = arrayMethods[key];
+			if (method !== void 0) {
+				trackArrayMethod(target);
+				return method;
+			}
+		}
+		const desc = getDescriptor(source, key);
+		return desc ? `value` in desc ? desc.value : (_a = desc.get) === null || _a === void 0 ? void 0 : _a.call(target.proxy) : void 0;
+	}
+	const value = source[key];
+	if (options.strict) checkReadable(value, options);
+	if (target.finalized || typeof value !== "object" || value === null) return value;
+	if (value === target.child && key === target.childKey) return value;
+	const children = target.children;
+	if (children !== void 0 && (type === 1 ? children[key] : children.get(key)) === value) return value;
+	if (!isDraftable(value, options)) return value;
+	let draftKey = key;
+	if (value !== target.original[key]) {
+		draftKey = baseIndex(target, value, key);
+		if (draftKey === -1) return value;
+	}
+	ensureShallowCopy(target);
+	const draft = createDraft(value, target, type === 1 ? Number(draftKey) : draftKey, target.finalities, options);
+	target.copy[key] = draft;
+	if (draftKey !== key) markFinalization(target, key, draft);
+	if (target.child === null || target.childKey === key) {
+		target.child = draft;
+		target.childKey = key;
+	} else if (type === 1) ((_b = target.children) !== null && _b !== void 0 ? _b : target.children = [])[key] = draft;
+	else ((_c = target.children) !== null && _c !== void 0 ? _c : target.children = /* @__PURE__ */ new Map()).set(key, draft);
+	if (typeof markResult === "function") {
+		const subProxyDraft = getProxyDraft(draft);
+		ensureShallowCopy(subProxyDraft);
+		markChanged(subProxyDraft);
+		return subProxyDraft.copy;
+	}
+	return draft;
+}
+function setTrap(target, key, value) {
+	var _a;
+	if (target.type === 3 || target.type === 2) die(1);
+	if (target.type === 1 && key !== "length" && !isArrayIndexKey(key)) die(2);
+	const source = latest(target);
+	if (!hasOwn.call(source, key)) {
+		const desc = getDescriptor(source, key);
+		if (desc === null || desc === void 0 ? void 0 : desc.set) {
+			desc.set.call(target.proxy, value);
+			return true;
+		}
+	}
+	const current = source[key];
+	const currentProxyDraft = getProxyDraft(current);
+	const original = target.original;
+	if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
+		target.copy[key] = value;
+		target.assignedMap = (_a = target.assignedMap) !== null && _a !== void 0 ? _a : /* @__PURE__ */ new Map();
+		if (hasOwn.call(original, key) && isEqual(value, original[key])) target.assignedMap.delete(key);
+		else {
+			markChanged(target);
+			target.assignedMap.set(key, true);
+			markFinalization(target, key, value);
+		}
+		return true;
+	}
+	if (isEqual(value, current) && (value !== void 0 || hasOwn.call(source, key)) && (target.arrayState === null || !isMovedElement(target, value, key))) return true;
+	ensureShallowCopy(target);
+	markChanged(target);
+	const arrayState = target.arrayState;
+	if (arrayState !== null && (typeof value === "object" && value !== null || typeof value === "function")) arrayState.inert = null;
+	if (hasOwn.call(original, key) && isEqual(value, original[key])) target.assignedMap.delete(key);
+	else target.assignedMap.set(key, true);
+	const length = target.type === 1 ? target.copy.length : -1;
+	target.copy[key] = value;
+	if (length !== -1 && target.copy.length > length + (key === "length" ? 0 : 1)) resized(target, length);
+	markFinalization(target, key, value);
+	return true;
+}
+function hasTrap(target, key) {
+	return key in latest(target);
+}
+function ownKeysTrap(target) {
+	return Reflect.ownKeys(latest(target));
+}
+function getOwnPropertyDescriptorTrap(target, key) {
+	const source = latest(target);
+	const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+	if (!descriptor) return descriptor;
+	return {
+		writable: true,
+		configurable: target.type !== 1 || key !== "length",
+		enumerable: descriptor.enumerable,
+		value: source[key]
+	};
+}
+function getPrototypeOfTrap(target) {
+	return Reflect.getPrototypeOf(target.original);
+}
+function setPrototypeOfTrap() {
+	die(3);
+}
+function definePropertyTrap() {
+	die(4);
+}
+function deletePropertyTrap(target, key) {
+	var _a;
+	if (target.type === 1) {
+		if (!hasOwn.call(latest(target), key) && isArrayIndexKey(key)) return true;
+		return setTrap(target, key, void 0);
+	}
+	if (target.original[key] !== void 0 || key in target.original) {
+		ensureShallowCopy(target);
+		markChanged(target);
+		target.assignedMap.set(key, false);
+	} else {
+		target.assignedMap = (_a = target.assignedMap) !== null && _a !== void 0 ? _a : /* @__PURE__ */ new Map();
+		target.assignedMap.delete(key);
+	}
+	if (target.copy) delete target.copy[key];
+	return true;
+}
+const objectHandler = {
+	get: getTrap,
+	set: setTrap,
+	has: hasTrap,
+	ownKeys: ownKeysTrap,
+	getOwnPropertyDescriptor: getOwnPropertyDescriptorTrap,
+	getPrototypeOf: getPrototypeOfTrap,
+	setPrototypeOf: setPrototypeOfTrap,
+	defineProperty: definePropertyTrap,
+	deleteProperty: deletePropertyTrap
+};
+const arrayHandler = {};
+Object.keys(objectHandler).forEach((name) => {
+	const trap = objectHandler[name];
+	arrayHandler[name] = (target, key, value) => trap(target[0], key, value);
+});
+function createDraft(original, parentDraft, key, finalities, options) {
+	const type = getType(original);
+	const proxyDraft = {
+		type,
+		finalized: false,
+		operated: false,
+		parent: parentDraft,
+		key,
+		original,
+		copy: null,
+		proxy: null,
+		finalities,
+		options,
+		setMap: void 0,
+		assignedMap: void 0,
+		callbacks: void 0,
+		children: void 0,
+		child: null,
+		childKey: null,
+		arrayState: null
+	};
+	const { proxy, revoke } = type === 1 ? Proxy.revocable([proxyDraft], arrayHandler) : Proxy.revocable(proxyDraft, objectHandler);
+	finalities.revoke.push(revoke);
+	proxyDraft.proxy = proxy;
+	finalities.draft.push(proxyDraft);
+	return proxy;
+}
+internal.createDraft = createDraft;
+const UNCHANGED_DRAFTS_WARNING_THRESHOLD = 1e3;
+let unchangedDraftsWarned = false;
+/**
+* Every object read through a draft becomes a draft, so a search through a
+* large draft array creates one per element it visits. Drafts that are
+* unchanged and still at the key they were read from count; elements that
+* array methods drafted when removing or moving them do not. An object or
+* array draft has a copy before it drafts a child.
+*/
+function warnUnchangedDrafts(finalities) {
+	let count = 0;
+	for (const entry of finalities.draft) if (typeof entry !== "function" && !entry.operated) {
+		const parent = entry.parent;
+		if (parent !== null && (parent.type === 1 || parent.type === 0) && parent.copy[entry.key] === entry.proxy) count += 1;
+	}
+	if (count >= UNCHANGED_DRAFTS_WARNING_THRESHOLD) {
+		unchangedDraftsWarned = true;
+		console.warn(`Strict mode: the recipe left ${count} drafts unchanged; every object read through a draft becomes one. For read-only scans of large arrays, search 'current(draft.list)' instead; see https://mutative.js.org/docs/api-reference/current`);
+	}
+}
+function finalizeDraft(result, returnedValue, patches, inversePatches, enableAutoFreeze) {
+	var _a;
+	const proxyDraft = getProxyDraft(result);
+	if ((proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.options.strict) && !unchangedDraftsWarned) warnUnchangedDrafts(proxyDraft.finalities);
+	const original = (_a = proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.original) !== null && _a !== void 0 ? _a : result;
+	const hasReturnedValue = !!returnedValue.length;
+	if (proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.operated) {
+		const list = proxyDraft.finalities.draft;
+		while (list.length > 0) {
+			const entry = list.pop();
+			if (typeof entry === "function") entry(patches, inversePatches);
+			else finalizeNode(entry, generatePatches, patches, inversePatches);
+		}
+	}
+	const state = hasReturnedValue ? returnedValue[0] : proxyDraft ? proxyDraft.operated ? proxyDraft.copy : proxyDraft.original : result;
+	if (proxyDraft) revokeProxy(proxyDraft.finalities);
+	if (enableAutoFreeze) deepFreeze(state);
+	return [
+		state,
+		patches && hasReturnedValue ? [{
+			op: Operation.Replace,
+			path: [],
+			value: returnedValue[0]
+		}] : patches,
+		inversePatches && hasReturnedValue ? [{
+			op: Operation.Replace,
+			path: [],
+			value: original
+		}] : inversePatches
+	];
+}
+
+//#endregion
+//#region src/draftify.ts
+function draftify(baseState, options) {
+	var _a;
+	const finalities = {
+		draft: [],
+		revoke: [],
+		handledSet: /* @__PURE__ */ new WeakSet(),
+		scoped: true
+	};
+	let patches;
+	let inversePatches;
+	if (options.enablePatches) {
+		patches = [];
+		inversePatches = [];
+	}
+	const draft = ((_a = options.mark) === null || _a === void 0 ? void 0 : _a.call(options, baseState, dataTypes)) === dataTypes.mutable || !isDraftable(baseState, options) ? baseState : createDraft(baseState, null, void 0, finalities, options);
+	return [
+		draft,
+		(returnedValue = []) => {
+			const [finalizedState, finalizedPatches, finalizedInversePatches] = finalizeDraft(draft, returnedValue, patches, inversePatches, options.enableAutoFreeze);
+			return options.enablePatches ? [
+				finalizedState,
+				finalizedPatches,
+				finalizedInversePatches
+			] : finalizedState;
+		},
+		finalities
+	];
+}
+
+//#endregion
+//#region src/makeCreator.ts
+let draftBaseWarned = false;
+/**
+* `makeCreator(options)` to make a creator function.
+*
+* ## Example
+*
+* ```ts
+* import { makeCreator } from 'mutative';
+*
+* const baseState = { foo: { bar: 'str' }, arr: [] };
+* const create = makeCreator({ enableAutoFreeze: true });
+* const state = create(
+*   baseState,
+*   (draft) => {
+*     draft.foo.bar = 'str2';
+*   },
+* );
+*
+* expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+* expect(state).not.toBe(baseState);
+* expect(state.foo).not.toBe(baseState.foo);
+* expect(state.arr).toBe(baseState.arr);
+* expect(Object.isFrozen(state)).toBeTruthy();
+* ```
+*/
+const makeCreator = (arg) => {
+	if (arg !== void 0 && Object.prototype.toString.call(arg) !== "[object Object]") throw new Error(`Invalid options: ${String(arg)}, 'options' should be an object.`);
+	return function create(arg0, arg1, arg2) {
+		var _a, _b, _c;
+		if (typeof arg0 === "function" && typeof arg1 !== "function") return function(base, ...args) {
+			return create(base, (draft) => arg0.call(this, draft, ...args), arg1);
+		};
+		const base = arg0;
+		const mutate = arg1;
+		let options = arg2;
+		if (typeof arg1 !== "function") options = arg1;
+		if (options !== void 0 && Object.prototype.toString.call(options) !== "[object Object]") throw new Error(`Invalid options: ${options}, 'options' should be an object.`);
+		options = {
+			...arg,
+			...options
+		};
+		const draftBase = isDraft(base);
+		if (draftBase && typeof arg1 === "function" && !draftBaseWarned) {
+			draftBaseWarned = true;
+			console.warn(`create() received a draft as its base and drafts current(draft), unlike Immer's produce: the values that its recipe leaves unchanged are objects of the base state, so changing them after the result is assigned back changes the base state. Make such changes in the recipe or before calling create(); see https://mutative.js.org/docs/api-reference/create#create-on-a-draft`);
+		}
+		const state = draftBase ? current(base) : base;
+		const mark = Array.isArray(options.mark) ? ((value, types) => {
+			for (const mark of options.mark) {
+				if (typeof mark !== "function") throw new Error(`Invalid mark: ${mark}, 'mark' should be a function.`);
+				const result = mark(value, types);
+				if (result) return result;
+			}
+		}) : options.mark;
+		const enablePatches = (_a = options.enablePatches) !== null && _a !== void 0 ? _a : false;
+		const strict = (_b = options.strict) !== null && _b !== void 0 ? _b : false;
+		const _options = {
+			enableAutoFreeze: (_c = options.enableAutoFreeze) !== null && _c !== void 0 ? _c : false,
+			mark,
+			strict,
+			enablePatches
+		};
+		if (!isDraftable(state, _options) && typeof state === "object" && state !== null) die(0);
+		const [draft, finalize, finalities] = draftify(state, _options);
+		if (typeof arg1 !== "function") {
+			if (!isDraftable(state, _options)) die(0);
+			finalities.scoped = false;
+			return [draft, finalize];
+		}
+		function fail(error) {
+			revokeProxy(finalities);
+			releaseArrayMethods(finalities.revoke);
+			throw error;
+		}
+		let result;
+		try {
+			result = mutate(draft);
+		} catch (error) {
+			fail(error);
+		}
+		const returnValue = (value) => {
+			const proxyDraft = getProxyDraft(draft);
+			if (!isDraft(value)) {
+				if (value !== void 0 && !isEqual(value, draft) && (proxyDraft === null || proxyDraft === void 0 ? void 0 : proxyDraft.operated)) die(5);
+				const rawReturnValue = value === null || value === void 0 ? void 0 : value[RAW_RETURN_SYMBOL];
+				if (rawReturnValue) {
+					const _value = rawReturnValue[0];
+					if (_options.strict && typeof value === "object" && value !== null) handleReturnValue(proxyDraft, value, true);
+					return finalize([_value]);
+				}
+				if (value !== void 0) {
+					if (typeof value === "object" && value !== null) handleReturnValue(proxyDraft, value);
+					return finalize([value]);
+				}
+			}
+			if (value === draft || value === void 0) return finalize([]);
+			const returnedProxyDraft = getProxyDraft(value);
+			if (_options === returnedProxyDraft.options) {
+				if (returnedProxyDraft.operated) die(6);
+				return finalize([current(value)]);
+			}
+			return finalize([value]);
+		};
+		const finish = (value) => {
+			try {
+				return returnValue(value);
+			} catch (error) {
+				return fail(error);
+			} finally {
+				releaseArrayMethods(finalities.revoke);
+			}
+		};
+		try {
+			if (result instanceof Promise) return result.then(finish, fail);
+		} catch (error) {
+			return fail(error);
+		}
+		return finish(result);
+	};
+};
+
+//#endregion
+//#region src/create.ts
+/**
+* `create(baseState, callback, options)` to create the next state
+*
+* ## Example
+*
+* ```ts
+* import { create } from 'mutative';
+*
+* const baseState = { foo: { bar: 'str' }, arr: [] };
+* const state = create(
+*   baseState,
+*   (draft) => {
+*     draft.foo.bar = 'str2';
+*   },
+* );
+*
+* expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+* expect(state).not.toBe(baseState);
+* expect(state.foo).not.toBe(baseState.foo);
+* expect(state.arr).toBe(baseState.arr);
+* ```
+*/
+const create = makeCreator();
+
+//#endregion
+//#region src/apply.ts
+function getPatchTargetType(value) {
+	try {
+		const proxyDraft = getProxyDraft(value);
+		if (proxyDraft) return proxyDraft.type;
+	} catch (_a) {}
+	return getType(value);
+}
+function normalizePatchKey(key) {
+	return typeof key === "object" || typeof key === "function" ? Reflect.ownKeys({ [key]: 0 })[0] : key;
+}
+function apply(state, patches, applyOptions) {
+	const mutable = applyOptions === null || applyOptions === void 0 ? void 0 : applyOptions.mutable;
+	let i;
+	for (i = patches.length - 1; i >= 0; i -= 1) {
+		const { value, op, path } = patches[i];
+		if (!path.length && op === Operation.Replace || path === "" && op === Operation.Add) {
+			if (mutable && value !== state) die(21);
+			state = value;
+			break;
+		}
+	}
+	if (i > -1) patches = patches.slice(i + 1);
+	const getTargetType = mutable ? getType : getPatchTargetType;
+	const mutate = (draft) => {
+		patches.forEach((patch) => {
+			const { path: _path, op } = patch;
+			const path = unescapePath(_path);
+			let base = draft;
+			for (let index = 0; index < path.length - 1; index += 1) {
+				const parentType = getTargetType(base);
+				let key = path[index];
+				if (parentType <= 1) {
+					key = normalizePatchKey(key);
+					if (key === "__proto__" || key === "constructor" || typeof base === "function" && key === "prototype") die(13);
+				}
+				if (parentType === 3) {
+					key = normalizePatchKey(key);
+					base = Array.from(base);
+					if (typeof key !== "number" && !has(base, key)) die(14, path);
+				}
+				base = parentType === 2 ? base.get(key) : base[key];
+				if (typeof base !== "object") die(14, path);
+			}
+			const type = getTargetType(base);
+			const value = deepClone(patch.value);
+			let key = path[path.length - 1];
+			if (type <= 1) {
+				if (type === 0 || op === Operation.Replace) key = normalizePatchKey(key);
+				if (key === "__proto__") die(13);
+			}
+			switch (op) {
+				case Operation.Replace: switch (type) {
+					case 2: return base.set(key, value);
+					case 3: return die(15);
+					default: return base[key] = value;
+				}
+				case Operation.Add: switch (type) {
+					case 1: return key === "-" ? base.push(value) : base.splice(key, 0, value);
+					case 2: return base.set(key, value);
+					case 3: return base.add(value);
+					default: return base[key] = value;
+				}
+				case Operation.Remove: switch (type) {
+					case 1: return base.splice(key, 1);
+					case 2: return base.delete(key);
+					case 3: return base.delete(patch.value);
+					default: return delete base[key];
+				}
+				default: die(16, op);
+			}
+		});
+	};
+	if (mutable) {
+		if (Object.keys(applyOptions).filter((key) => key !== "mutable").length) console.warn("The \"mutable\" option is not allowed to be used with other options.");
+		mutate(state);
+		return;
+	}
+	if (isDraft(state)) {
+		if (applyOptions !== void 0) die(17);
+		mutate(state);
+		return state;
+	}
+	return create(state, mutate, {
+		...applyOptions,
+		enablePatches: false
+	});
+}
+
+//#endregion
+//#region src/original.ts
+/**
+* `original(draft)` to get original state in the draft mutation function.
+*
+* ## Example
+*
+* ```ts
+* import { create, original } from 'mutative';
+*
+* const baseState = { foo: { bar: 'str' }, arr: [] };
+* const state = create(
+*   baseState,
+*   (draft) => {
+*     draft.foo.bar = 'str2';
+*     expect(original(draft.foo)).toEqual({ bar: 'str' });
+*   }
+* );
+* ```
+*/
+function original(target) {
+	const proxyDraft = getProxyDraft(target);
+	if (!proxyDraft) die(18, target);
+	return proxyDraft.original;
+}
+
+//#endregion
+//#region src/rawReturn.ts
+/**
+* Use rawReturn() to wrap the return value to skip the draft check and thus improve performance.
+*
+* ## Example
+*
+* ```ts
+* import { create, rawReturn } from 'mutative';
+*
+* const baseState = { foo: { bar: 'str' }, arr: [] };
+* const state = create(
+*   baseState,
+*   (draft) => {
+*     return rawReturn(baseState);
+*   },
+* );
+* expect(state).toBe(baseState);
+* ```
+*/
+function rawReturn(value) {
+	if (arguments.length === 0) die(19);
+	if (arguments.length > 1) die(20);
+	if (value !== void 0 && (typeof value !== "object" || value === null)) 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().");
+	return { [RAW_RETURN_SYMBOL]: [value] };
+}
+
+//#endregion
+//#region src/utils/marker.ts
+const constructorString = Object.prototype.constructor.toString();
+const isSimpleObject = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype === null) return true;
+	const constructor = Object.hasOwnProperty.call(prototype, "constructor") && prototype.constructor;
+	if (constructor === Object) return true;
+	return typeof constructor === "function" && Function.toString.call(constructor) === constructorString;
+};
+/**
+* A `mark` that drafts plain objects, objects without a prototype and plain
+* objects of other realms, such as same-origin iframes.
+*/
+const markSimpleObject = (value) => {
+	if (isSimpleObject(value)) return dataTypes.immutable;
+};
+
+//#endregion
+//#region src/utils/cast.ts
+/**
+* Cast a value to its draft type; it returns the value as it is.
+*/
+function castDraft(value) {
+	return value;
+}
+/**
+* Cast a value to its immutable type, without freezing it.
+*/
+function castImmutable(value) {
+	return value;
+}
+/**
+* Cast a draft to the type of its base state.
+*/
+function castMutable(draft) {
+	return draft;
+}
+
+//#endregion
+exports.apply = apply;
+exports.castDraft = castDraft;
+exports.castImmutable = castImmutable;
+exports.castMutable = castMutable;
+exports.create = create;
+exports.current = current;
+exports.isDraft = isDraft;
+exports.isDraftable = isDraftable;
+exports.makeCreator = makeCreator;
+exports.markSimpleObject = markSimpleObject;
+exports.original = original;
+exports.rawReturn = rawReturn;
+exports.unsafe = unsafe;
+//# sourceMappingURL=mutative.cjs.development.js.map