@accelint/map-toolkit 0.5.0 → 0.6.0

package/dist/node_modules/.pnpm/immer@10.2.0/node_modules/immer/dist/immer.js

@@ -1,812 +0,0 @@
-/*
- * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-
-//#region ../../node_modules/.pnpm/immer@10.2.0/node_modules/immer/dist/immer.mjs
-var NOTHING = Symbol.for("immer-nothing");
-var DRAFTABLE = Symbol.for("immer-draftable");
-var DRAFT_STATE = Symbol.for("immer-state");
-var errors = process.env.NODE_ENV !== "production" ? [
-	function(plugin) {
-		return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
-	},
-	function(thing) {
-		return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
-	},
-	"This object has been frozen and should not be mutated",
-	function(data) {
-		return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
-	},
-	"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
-	"Immer forbids circular references",
-	"The first or second argument to `produce` must be a function",
-	"The third argument to `produce` must be a function or undefined",
-	"First argument to `createDraft` must be a plain object, an array, or an immerable object",
-	"First argument to `finishDraft` must be a draft returned by `createDraft`",
-	function(thing) {
-		return `'current' expects a draft, got: ${thing}`;
-	},
-	"Object.defineProperty() cannot be used on an Immer draft",
-	"Object.setPrototypeOf() cannot be used on an Immer draft",
-	"Immer only supports deleting array indices",
-	"Immer only supports setting array indices and the 'length' property",
-	function(thing) {
-		return `'original' expects a draft, got: ${thing}`;
-	}
-] : [];
-function die(error, ...args) {
-	if (process.env.NODE_ENV !== "production") {
-		const e = errors[error];
-		const msg = typeof e === "function" ? e.apply(null, args) : e;
-		throw new Error(`[Immer] ${msg}`);
-	}
-	throw new Error(`[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`);
-}
-var getPrototypeOf = Object.getPrototypeOf;
-function isDraft(value) {
-	return !!value && !!value[DRAFT_STATE];
-}
-function isDraftable(value) {
-	if (!value) return false;
-	return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
-}
-var objectCtorString = Object.prototype.constructor.toString();
-var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
-function isPlainObject(value) {
-	if (!value || typeof value !== "object") return false;
-	const proto = Object.getPrototypeOf(value);
-	if (proto === null || proto === Object.prototype) return true;
-	const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-	if (Ctor === Object) return true;
-	if (typeof Ctor !== "function") return false;
-	let ctorString = cachedCtorStrings.get(Ctor);
-	if (ctorString === void 0) {
-		ctorString = Function.toString.call(Ctor);
-		cachedCtorStrings.set(Ctor, ctorString);
-	}
-	return ctorString === objectCtorString;
-}
-function each(obj, iter, strict = true) {
-	if (getArchtype(obj) === 0) (strict ? Reflect.ownKeys(obj) : Object.keys(obj)).forEach((key) => {
-		iter(key, obj[key], obj);
-	});
-	else obj.forEach((entry, index) => iter(index, entry, obj));
-}
-function getArchtype(thing) {
-	const state = thing[DRAFT_STATE];
-	return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
-}
-function has(thing, prop) {
-	return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
-}
-function set(thing, propOrOldValue, value) {
-	const t = getArchtype(thing);
-	if (t === 2) thing.set(propOrOldValue, value);
-	else if (t === 3) thing.add(value);
-	else thing[propOrOldValue] = value;
-}
-function is(x, y) {
-	if (x === y) return x !== 0 || 1 / x === 1 / y;
-	else return x !== x && y !== y;
-}
-function isMap(target) {
-	return target instanceof Map;
-}
-function isSet(target) {
-	return target instanceof Set;
-}
-function latest(state) {
-	return state.copy_ || state.base_;
-}
-function shallowCopy(base, strict) {
-	if (isMap(base)) return new Map(base);
-	if (isSet(base)) return new Set(base);
-	if (Array.isArray(base)) return Array.prototype.slice.call(base);
-	const isPlain = isPlainObject(base);
-	if (strict === true || strict === "class_only" && !isPlain) {
-		const descriptors = Object.getOwnPropertyDescriptors(base);
-		delete descriptors[DRAFT_STATE];
-		let keys = Reflect.ownKeys(descriptors);
-		for (let i = 0; i < keys.length; i++) {
-			const key = keys[i];
-			const desc = descriptors[key];
-			if (desc.writable === false) {
-				desc.writable = true;
-				desc.configurable = true;
-			}
-			if (desc.get || desc.set) descriptors[key] = {
-				configurable: true,
-				writable: true,
-				enumerable: desc.enumerable,
-				value: base[key]
-			};
-		}
-		return Object.create(getPrototypeOf(base), descriptors);
-	} else {
-		const proto = getPrototypeOf(base);
-		if (proto !== null && isPlain) return { ...base };
-		const obj = Object.create(proto);
-		return Object.assign(obj, base);
-	}
-}
-function freeze(obj, deep = false) {
-	if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
-	if (getArchtype(obj) > 1) Object.defineProperties(obj, {
-		set: dontMutateMethodOverride,
-		add: dontMutateMethodOverride,
-		clear: dontMutateMethodOverride,
-		delete: dontMutateMethodOverride
-	});
-	Object.freeze(obj);
-	if (deep) Object.values(obj).forEach((value) => freeze(value, true));
-	return obj;
-}
-function dontMutateFrozenCollections() {
-	die(2);
-}
-var dontMutateMethodOverride = { value: dontMutateFrozenCollections };
-function isFrozen(obj) {
-	if (obj === null || typeof obj !== "object") return true;
-	return Object.isFrozen(obj);
-}
-var plugins = {};
-function getPlugin(pluginKey) {
-	const plugin = plugins[pluginKey];
-	if (!plugin) die(0, pluginKey);
-	return plugin;
-}
-function loadPlugin(pluginKey, implementation) {
-	if (!plugins[pluginKey]) plugins[pluginKey] = implementation;
-}
-var currentScope;
-function getCurrentScope() {
-	return currentScope;
-}
-function createScope(parent_, immer_) {
-	return {
-		drafts_: [],
-		parent_,
-		immer_,
-		canAutoFreeze_: true,
-		unfinalizedDrafts_: 0
-	};
-}
-function usePatchesInScope(scope, patchListener) {
-	if (patchListener) {
-		getPlugin("Patches");
-		scope.patches_ = [];
-		scope.inversePatches_ = [];
-		scope.patchListener_ = patchListener;
-	}
-}
-function revokeScope(scope) {
-	leaveScope(scope);
-	scope.drafts_.forEach(revokeDraft);
-	scope.drafts_ = null;
-}
-function leaveScope(scope) {
-	if (scope === currentScope) currentScope = scope.parent_;
-}
-function enterScope(immer2) {
-	return currentScope = createScope(currentScope, immer2);
-}
-function revokeDraft(draft) {
-	const state = draft[DRAFT_STATE];
-	if (state.type_ === 0 || state.type_ === 1) state.revoke_();
-	else state.revoked_ = true;
-}
-function processResult(result, scope) {
-	scope.unfinalizedDrafts_ = scope.drafts_.length;
-	const baseDraft = scope.drafts_[0];
-	if (result !== void 0 && result !== baseDraft) {
-		if (baseDraft[DRAFT_STATE].modified_) {
-			revokeScope(scope);
-			die(4);
-		}
-		if (isDraftable(result)) {
-			result = finalize(scope, result);
-			if (!scope.parent_) maybeFreeze(scope, result);
-		}
-		if (scope.patches_) getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_);
-	} else result = finalize(scope, baseDraft, []);
-	revokeScope(scope);
-	if (scope.patches_) scope.patchListener_(scope.patches_, scope.inversePatches_);
-	return result !== NOTHING ? result : void 0;
-}
-function finalize(rootScope, value, path) {
-	if (isFrozen(value)) return value;
-	const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
-	const state = value[DRAFT_STATE];
-	if (!state) {
-		each(value, (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path), useStrictIteration);
-		return value;
-	}
-	if (state.scope_ !== rootScope) return value;
-	if (!state.modified_) {
-		maybeFreeze(rootScope, state.base_, true);
-		return state.base_;
-	}
-	if (!state.finalized_) {
-		state.finalized_ = true;
-		state.scope_.unfinalizedDrafts_--;
-		const result = state.copy_;
-		let resultEach = result;
-		let isSet2 = false;
-		if (state.type_ === 3) {
-			resultEach = new Set(result);
-			result.clear();
-			isSet2 = true;
-		}
-		each(resultEach, (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2), useStrictIteration);
-		maybeFreeze(rootScope, result, false);
-		if (path && rootScope.patches_) getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_);
-	}
-	return state.copy_;
-}
-function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
-	if (childValue == null) return;
-	if (typeof childValue !== "object" && !targetIsSet) return;
-	const childIsFrozen = isFrozen(childValue);
-	if (childIsFrozen && !targetIsSet) return;
-	if (process.env.NODE_ENV !== "production" && childValue === targetObject) die(5);
-	if (isDraft(childValue)) {
-		const res = finalize(rootScope, childValue, rootPath && parentState && parentState.type_ !== 3 && !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0);
-		set(targetObject, prop, res);
-		if (isDraft(res)) rootScope.canAutoFreeze_ = false;
-		else return;
-	} else if (targetIsSet) targetObject.add(childValue);
-	if (isDraftable(childValue) && !childIsFrozen) {
-		if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) return;
-		if (parentState && parentState.base_ && parentState.base_[prop] === childValue && childIsFrozen) return;
-		finalize(rootScope, childValue);
-		if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop))) maybeFreeze(rootScope, childValue);
-	}
-}
-function maybeFreeze(scope, value, deep = false) {
-	if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) freeze(value, deep);
-}
-function createProxyProxy(base, parent) {
-	const isArray = Array.isArray(base);
-	const state = {
-		type_: isArray ? 1 : 0,
-		scope_: parent ? parent.scope_ : getCurrentScope(),
-		modified_: false,
-		finalized_: false,
-		assigned_: {},
-		parent_: parent,
-		base_: base,
-		draft_: null,
-		copy_: null,
-		revoke_: null,
-		isManual_: false
-	};
-	let target = state;
-	let traps = objectTraps;
-	if (isArray) {
-		target = [state];
-		traps = arrayTraps;
-	}
-	const { revoke, proxy } = Proxy.revocable(target, traps);
-	state.draft_ = proxy;
-	state.revoke_ = revoke;
-	return proxy;
-}
-var objectTraps = {
-	get(state, prop) {
-		if (prop === DRAFT_STATE) return state;
-		const source = latest(state);
-		if (!has(source, prop)) return readPropFromProto(state, source, prop);
-		const value = source[prop];
-		if (state.finalized_ || !isDraftable(value)) return value;
-		if (value === peek(state.base_, prop)) {
-			prepareCopy(state);
-			return state.copy_[prop] = createProxy(value, state);
-		}
-		return value;
-	},
-	has(state, prop) {
-		return prop in latest(state);
-	},
-	ownKeys(state) {
-		return Reflect.ownKeys(latest(state));
-	},
-	set(state, prop, value) {
-		const desc = getDescriptorFromProto(latest(state), prop);
-		if (desc?.set) {
-			desc.set.call(state.draft_, value);
-			return true;
-		}
-		if (!state.modified_) {
-			const current2 = peek(latest(state), prop);
-			const currentState = current2?.[DRAFT_STATE];
-			if (currentState && currentState.base_ === value) {
-				state.copy_[prop] = value;
-				state.assigned_[prop] = false;
-				return true;
-			}
-			if (is(value, current2) && (value !== void 0 || has(state.base_, prop))) return true;
-			prepareCopy(state);
-			markChanged(state);
-		}
-		if (state.copy_[prop] === value && (value !== void 0 || prop in state.copy_) || Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true;
-		state.copy_[prop] = value;
-		state.assigned_[prop] = true;
-		return true;
-	},
-	deleteProperty(state, prop) {
-		if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
-			state.assigned_[prop] = false;
-			prepareCopy(state);
-			markChanged(state);
-		} else delete state.assigned_[prop];
-		if (state.copy_) delete state.copy_[prop];
-		return true;
-	},
-	getOwnPropertyDescriptor(state, prop) {
-		const owner = latest(state);
-		const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
-		if (!desc) return desc;
-		return {
-			writable: true,
-			configurable: state.type_ !== 1 || prop !== "length",
-			enumerable: desc.enumerable,
-			value: owner[prop]
-		};
-	},
-	defineProperty() {
-		die(11);
-	},
-	getPrototypeOf(state) {
-		return getPrototypeOf(state.base_);
-	},
-	setPrototypeOf() {
-		die(12);
-	}
-};
-var arrayTraps = {};
-each(objectTraps, (key, fn) => {
-	arrayTraps[key] = function() {
-		arguments[0] = arguments[0][0];
-		return fn.apply(this, arguments);
-	};
-});
-arrayTraps.deleteProperty = function(state, prop) {
-	if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop))) die(13);
-	return arrayTraps.set.call(this, state, prop, void 0);
-};
-arrayTraps.set = function(state, prop, value) {
-	if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop))) die(14);
-	return objectTraps.set.call(this, state[0], prop, value, state[0]);
-};
-function peek(draft, prop) {
-	const state = draft[DRAFT_STATE];
-	return (state ? latest(state) : draft)[prop];
-}
-function readPropFromProto(state, source, prop) {
-	const desc = getDescriptorFromProto(source, prop);
-	return desc ? `value` in desc ? desc.value : desc.get?.call(state.draft_) : void 0;
-}
-function getDescriptorFromProto(source, prop) {
-	if (!(prop in source)) return void 0;
-	let proto = getPrototypeOf(source);
-	while (proto) {
-		const desc = Object.getOwnPropertyDescriptor(proto, prop);
-		if (desc) return desc;
-		proto = getPrototypeOf(proto);
-	}
-}
-function markChanged(state) {
-	if (!state.modified_) {
-		state.modified_ = true;
-		if (state.parent_) markChanged(state.parent_);
-	}
-}
-function prepareCopy(state) {
-	if (!state.copy_) state.copy_ = shallowCopy(state.base_, state.scope_.immer_.useStrictShallowCopy_);
-}
-var Immer2 = class {
-	constructor(config) {
-		this.autoFreeze_ = true;
-		this.useStrictShallowCopy_ = false;
-		this.useStrictIteration_ = true;
-		/**
-		* The `produce` function takes a value and a "recipe function" (whose
-		* return value often depends on the base state). The recipe function is
-		* free to mutate its first argument however it wants. All mutations are
-		* only ever applied to a __copy__ of the base state.
-		*
-		* Pass only a function to create a "curried producer" which relieves you
-		* from passing the recipe function every time.
-		*
-		* Only plain objects and arrays are made mutable. All other objects are
-		* considered uncopyable.
-		*
-		* Note: This function is __bound__ to its `Immer` instance.
-		*
-		* @param {any} base - the initial state
-		* @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
-		* @param {Function} patchListener - optional function that will be called with all the patches produced here
-		* @returns {any} a new state, or the initial state if nothing was modified
-		*/
-		this.produce = (base, recipe, patchListener) => {
-			if (typeof base === "function" && typeof recipe !== "function") {
-				const defaultBase = recipe;
-				recipe = base;
-				const self = this;
-				return function curriedProduce(base2 = defaultBase, ...args) {
-					return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
-				};
-			}
-			if (typeof recipe !== "function") die(6);
-			if (patchListener !== void 0 && typeof patchListener !== "function") die(7);
-			let result;
-			if (isDraftable(base)) {
-				const scope = enterScope(this);
-				const proxy = createProxy(base, void 0);
-				let hasError = true;
-				try {
-					result = recipe(proxy);
-					hasError = false;
-				} finally {
-					if (hasError) revokeScope(scope);
-					else leaveScope(scope);
-				}
-				usePatchesInScope(scope, patchListener);
-				return processResult(result, scope);
-			} else if (!base || typeof base !== "object") {
-				result = recipe(base);
-				if (result === void 0) result = base;
-				if (result === NOTHING) result = void 0;
-				if (this.autoFreeze_) freeze(result, true);
-				if (patchListener) {
-					const p = [];
-					const ip = [];
-					getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
-					patchListener(p, ip);
-				}
-				return result;
-			} else die(1, base);
-		};
-		this.produceWithPatches = (base, recipe) => {
-			if (typeof base === "function") return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
-			let patches, inversePatches;
-			return [
-				this.produce(base, recipe, (p, ip) => {
-					patches = p;
-					inversePatches = ip;
-				}),
-				patches,
-				inversePatches
-			];
-		};
-		if (typeof config?.autoFreeze === "boolean") this.setAutoFreeze(config.autoFreeze);
-		if (typeof config?.useStrictShallowCopy === "boolean") this.setUseStrictShallowCopy(config.useStrictShallowCopy);
-		if (typeof config?.useStrictIteration === "boolean") this.setUseStrictIteration(config.useStrictIteration);
-	}
-	createDraft(base) {
-		if (!isDraftable(base)) die(8);
-		if (isDraft(base)) base = current(base);
-		const scope = enterScope(this);
-		const proxy = createProxy(base, void 0);
-		proxy[DRAFT_STATE].isManual_ = true;
-		leaveScope(scope);
-		return proxy;
-	}
-	finishDraft(draft, patchListener) {
-		const state = draft && draft[DRAFT_STATE];
-		if (!state || !state.isManual_) die(9);
-		const { scope_: scope } = state;
-		usePatchesInScope(scope, patchListener);
-		return processResult(void 0, scope);
-	}
-	/**
-	* Pass true to automatically freeze all copies created by Immer.
-	*
-	* By default, auto-freezing is enabled.
-	*/
-	setAutoFreeze(value) {
-		this.autoFreeze_ = value;
-	}
-	/**
-	* Pass true to enable strict shallow copy.
-	*
-	* By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
-	*/
-	setUseStrictShallowCopy(value) {
-		this.useStrictShallowCopy_ = value;
-	}
-	/**
-	* Pass false to use faster iteration that skips non-enumerable properties
-	* but still handles symbols for compatibility.
-	*
-	* By default, strict iteration is enabled (includes all own properties).
-	*/
-	setUseStrictIteration(value) {
-		this.useStrictIteration_ = value;
-	}
-	shouldUseStrictIteration() {
-		return this.useStrictIteration_;
-	}
-	applyPatches(base, patches) {
-		let i;
-		for (i = patches.length - 1; i >= 0; i--) {
-			const patch = patches[i];
-			if (patch.path.length === 0 && patch.op === "replace") {
-				base = patch.value;
-				break;
-			}
-		}
-		if (i > -1) patches = patches.slice(i + 1);
-		const applyPatchesImpl = getPlugin("Patches").applyPatches_;
-		if (isDraft(base)) return applyPatchesImpl(base, patches);
-		return this.produce(base, (draft) => applyPatchesImpl(draft, patches));
-	}
-};
-function createProxy(value, parent) {
-	const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
-	(parent ? parent.scope_ : getCurrentScope()).drafts_.push(draft);
-	return draft;
-}
-function current(value) {
-	if (!isDraft(value)) die(10, value);
-	return currentImpl(value);
-}
-function currentImpl(value) {
-	if (!isDraftable(value) || isFrozen(value)) return value;
-	const state = value[DRAFT_STATE];
-	let copy;
-	let strict = true;
-	if (state) {
-		if (!state.modified_) return state.base_;
-		state.finalized_ = true;
-		copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
-		strict = state.scope_.immer_.shouldUseStrictIteration();
-	} else copy = shallowCopy(value, true);
-	each(copy, (key, childValue) => {
-		set(copy, key, currentImpl(childValue));
-	}, strict);
-	if (state) state.finalized_ = false;
-	return copy;
-}
-function enableMapSet() {
-	class DraftMap extends Map {
-		constructor(target, parent) {
-			super();
-			this[DRAFT_STATE] = {
-				type_: 2,
-				parent_: parent,
-				scope_: parent ? parent.scope_ : getCurrentScope(),
-				modified_: false,
-				finalized_: false,
-				copy_: void 0,
-				assigned_: void 0,
-				base_: target,
-				draft_: this,
-				isManual_: false,
-				revoked_: false
-			};
-		}
-		get size() {
-			return latest(this[DRAFT_STATE]).size;
-		}
-		has(key) {
-			return latest(this[DRAFT_STATE]).has(key);
-		}
-		set(key, value) {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			if (!latest(state).has(key) || latest(state).get(key) !== value) {
-				prepareMapCopy(state);
-				markChanged(state);
-				state.assigned_.set(key, true);
-				state.copy_.set(key, value);
-				state.assigned_.set(key, true);
-			}
-			return this;
-		}
-		delete(key) {
-			if (!this.has(key)) return false;
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			prepareMapCopy(state);
-			markChanged(state);
-			if (state.base_.has(key)) state.assigned_.set(key, false);
-			else state.assigned_.delete(key);
-			state.copy_.delete(key);
-			return true;
-		}
-		clear() {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			if (latest(state).size) {
-				prepareMapCopy(state);
-				markChanged(state);
-				state.assigned_ = /* @__PURE__ */ new Map();
-				each(state.base_, (key) => {
-					state.assigned_.set(key, false);
-				});
-				state.copy_.clear();
-			}
-		}
-		forEach(cb, thisArg) {
-			const state = this[DRAFT_STATE];
-			latest(state).forEach((_value, key, _map) => {
-				cb.call(thisArg, this.get(key), key, this);
-			});
-		}
-		get(key) {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			const value = latest(state).get(key);
-			if (state.finalized_ || !isDraftable(value)) return value;
-			if (value !== state.base_.get(key)) return value;
-			const draft = createProxy(value, state);
-			prepareMapCopy(state);
-			state.copy_.set(key, draft);
-			return draft;
-		}
-		keys() {
-			return latest(this[DRAFT_STATE]).keys();
-		}
-		values() {
-			const iterator = this.keys();
-			return {
-				[Symbol.iterator]: () => this.values(),
-				next: () => {
-					const r = iterator.next();
-					if (r.done) return r;
-					return {
-						done: false,
-						value: this.get(r.value)
-					};
-				}
-			};
-		}
-		entries() {
-			const iterator = this.keys();
-			return {
-				[Symbol.iterator]: () => this.entries(),
-				next: () => {
-					const r = iterator.next();
-					if (r.done) return r;
-					const value = this.get(r.value);
-					return {
-						done: false,
-						value: [r.value, value]
-					};
-				}
-			};
-		}
-		[Symbol.iterator]() {
-			return this.entries();
-		}
-	}
-	function proxyMap_(target, parent) {
-		return new DraftMap(target, parent);
-	}
-	function prepareMapCopy(state) {
-		if (!state.copy_) {
-			state.assigned_ = /* @__PURE__ */ new Map();
-			state.copy_ = new Map(state.base_);
-		}
-	}
-	class DraftSet extends Set {
-		constructor(target, parent) {
-			super();
-			this[DRAFT_STATE] = {
-				type_: 3,
-				parent_: parent,
-				scope_: parent ? parent.scope_ : getCurrentScope(),
-				modified_: false,
-				finalized_: false,
-				copy_: void 0,
-				base_: target,
-				draft_: this,
-				drafts_: /* @__PURE__ */ new Map(),
-				revoked_: false,
-				isManual_: false
-			};
-		}
-		get size() {
-			return latest(this[DRAFT_STATE]).size;
-		}
-		has(value) {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			if (!state.copy_) return state.base_.has(value);
-			if (state.copy_.has(value)) return true;
-			if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value))) return true;
-			return false;
-		}
-		add(value) {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			if (!this.has(value)) {
-				prepareSetCopy(state);
-				markChanged(state);
-				state.copy_.add(value);
-			}
-			return this;
-		}
-		delete(value) {
-			if (!this.has(value)) return false;
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			prepareSetCopy(state);
-			markChanged(state);
-			return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : false);
-		}
-		clear() {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			if (latest(state).size) {
-				prepareSetCopy(state);
-				markChanged(state);
-				state.copy_.clear();
-			}
-		}
-		values() {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			prepareSetCopy(state);
-			return state.copy_.values();
-		}
-		entries() {
-			const state = this[DRAFT_STATE];
-			assertUnrevoked(state);
-			prepareSetCopy(state);
-			return state.copy_.entries();
-		}
-		keys() {
-			return this.values();
-		}
-		[Symbol.iterator]() {
-			return this.values();
-		}
-		forEach(cb, thisArg) {
-			const iterator = this.values();
-			let result = iterator.next();
-			while (!result.done) {
-				cb.call(thisArg, result.value, result.value, this);
-				result = iterator.next();
-			}
-		}
-	}
-	function proxySet_(target, parent) {
-		return new DraftSet(target, parent);
-	}
-	function prepareSetCopy(state) {
-		if (!state.copy_) {
-			state.copy_ = /* @__PURE__ */ new Set();
-			state.base_.forEach((value) => {
-				if (isDraftable(value)) {
-					const draft = createProxy(value, state);
-					state.drafts_.set(value, draft);
-					state.copy_.add(draft);
-				} else state.copy_.add(value);
-			});
-		}
-	}
-	function assertUnrevoked(state) {
-		if (state.revoked_) die(3, JSON.stringify(latest(state)));
-	}
-	loadPlugin("MapSet", {
-		proxyMap_,
-		proxySet_
-	});
-}
-var immer = new Immer2();
-var produce = immer.produce;
-
-//#endregion
-export { enableMapSet, produce };
-//# sourceMappingURL=immer.js.map