@equinor/roma-framework 5.0.0-beta.0 → 5.0.0

package/dev-portal/roma-framework.umd.js

@@ -30493,9 +30493,9 @@
           {
             onScheduleRoot(container, element);
           }
-          var current$1 = container.current;
+          var current$12 = container.current;
           var eventTime = requestEventTime();
-          var lane = requestUpdateLane(current$1);
+          var lane = requestUpdateLane(current$12);
           {
             markRenderScheduled(lane);
           }
@@ -30524,10 +30524,10 @@
             }
             update.callback = callback;
           }
-          var root2 = enqueueUpdate(current$1, update, lane);
+          var root2 = enqueueUpdate(current$12, update, lane);
           if (root2 !== null) {
-            scheduleUpdateOnFiber(root2, current$1, lane, eventTime);
-            entangleTransitions(root2, current$1, lane);
+            scheduleUpdateOnFiber(root2, current$12, lane, eventTime);
+            entangleTransitions(root2, current$12, lane);
           }
           return lane;
         }
@@ -33540,7 +33540,7 @@
     var e2 = new Error(message);
     return e2.name = "SuppressedError", e2.error = error2, e2.suppressed = suppressed, e2;
   };
-  function isFunction$1(value) {
+  function isFunction$2(value) {
     return typeof value === "function";
   }
   function createErrorClass(createImpl) {
@@ -33604,7 +33604,7 @@
           }
         }
         var initialFinalizer = this.initialTeardown;
-        if (isFunction$1(initialFinalizer)) {
+        if (isFunction$2(initialFinalizer)) {
           try {
             initialFinalizer();
           } catch (e2) {
@@ -33691,10 +33691,10 @@
   })();
   var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
   function isSubscription(value) {
-    return value instanceof Subscription || value && "closed" in value && isFunction$1(value.remove) && isFunction$1(value.add) && isFunction$1(value.unsubscribe);
+    return value instanceof Subscription || value && "closed" in value && isFunction$2(value.remove) && isFunction$2(value.add) && isFunction$2(value.unsubscribe);
   }
   function execFinalizer(finalizer) {
-    if (isFunction$1(finalizer)) {
+    if (isFunction$2(finalizer)) {
       finalizer();
     } else {
       finalizer.unsubscribe();
@@ -33837,7 +33837,7 @@
     function SafeSubscriber2(observerOrNext, error2, complete) {
       var _this = _super.call(this) || this;
       var partialObserver;
-      if (isFunction$1(observerOrNext) || !observerOrNext) {
+      if (isFunction$2(observerOrNext) || !observerOrNext) {
         partialObserver = {
           next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
           error: error2 !== null && error2 !== void 0 ? error2 : void 0,
@@ -33971,13 +33971,13 @@
     return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config$1.Promise) !== null && _a !== void 0 ? _a : Promise;
   }
   function isObserver(value) {
-    return value && isFunction$1(value.next) && isFunction$1(value.error) && isFunction$1(value.complete);
+    return value && isFunction$2(value.next) && isFunction$2(value.error) && isFunction$2(value.complete);
   }
   function isSubscriber(value) {
     return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
   }
   function hasLift(source) {
-    return isFunction$1(source === null || source === void 0 ? void 0 : source.lift);
+    return isFunction$2(source === null || source === void 0 ? void 0 : source.lift);
   }
   function operate(init2) {
     return function(source) {
@@ -34464,13 +34464,13 @@
     return subscriber.complete();
   });
   function isScheduler(value) {
-    return value && isFunction$1(value.schedule);
+    return value && isFunction$2(value.schedule);
   }
   function last$1(arr) {
     return arr[arr.length - 1];
   }
   function popResultSelector(args) {
-    return isFunction$1(last$1(args)) ? args.pop() : void 0;
+    return isFunction$2(last$1(args)) ? args.pop() : void 0;
   }
   function popScheduler(args) {
     return isScheduler(last$1(args)) ? args.pop() : void 0;
@@ -34482,13 +34482,13 @@
     return x2 && typeof x2.length === "number" && typeof x2 !== "function";
   });
   function isPromise$1(value) {
-    return isFunction$1(value === null || value === void 0 ? void 0 : value.then);
+    return isFunction$2(value === null || value === void 0 ? void 0 : value.then);
   }
   function isInteropObservable(input) {
-    return isFunction$1(input[observable]);
+    return isFunction$2(input[observable]);
   }
   function isAsyncIterable(obj) {
-    return Symbol.asyncIterator && isFunction$1(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+    return Symbol.asyncIterator && isFunction$2(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
   }
   function createInvalidObservableTypeError(input) {
     return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
@@ -34501,7 +34501,7 @@
   }
   var iterator = getSymbolIterator();
   function isIterable$1(input) {
-    return isFunction$1(input === null || input === void 0 ? void 0 : input[iterator]);
+    return isFunction$2(input === null || input === void 0 ? void 0 : input[iterator]);
   }
   function readableStreamLikeToAsyncGenerator(readableStream) {
     return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
@@ -34541,7 +34541,7 @@
     });
   }
   function isReadableStreamLike(obj) {
-    return isFunction$1(obj === null || obj === void 0 ? void 0 : obj.getReader);
+    return isFunction$2(obj === null || obj === void 0 ? void 0 : obj.getReader);
   }
   function innerFrom(input) {
     if (input instanceof Observable) {
@@ -34572,7 +34572,7 @@
   function fromInteropObservable(obj) {
     return new Observable(function(subscriber) {
       var obs = obj[observable]();
-      if (isFunction$1(obs.subscribe)) {
+      if (isFunction$2(obs.subscribe)) {
         return obs.subscribe(subscriber);
       }
       throw new TypeError("Provided object does not correctly implement Symbol.observable");
@@ -34775,7 +34775,7 @@
         }, 0, true);
       });
       return function() {
-        return isFunction$1(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return();
+        return isFunction$2(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return();
       };
     });
   }
@@ -34836,7 +34836,7 @@
     return from$1(args, scheduler2);
   }
   function throwError(errorOrErrorFactory, scheduler2) {
-    var errorFactory = isFunction$1(errorOrErrorFactory) ? errorOrErrorFactory : function() {
+    var errorFactory = isFunction$2(errorOrErrorFactory) ? errorOrErrorFactory : function() {
       return errorOrErrorFactory;
     };
     var init2 = function(subscriber) {
@@ -34845,7 +34845,7 @@
     return new Observable(init2);
   }
   function isObservable(obj) {
-    return !!obj && (obj instanceof Observable || isFunction$1(obj.lift) && isFunction$1(obj.subscribe));
+    return !!obj && (obj instanceof Observable || isFunction$2(obj.lift) && isFunction$2(obj.subscribe));
   }
   var EmptyError = createErrorClass(function(_super) {
     return function EmptyErrorImpl() {
@@ -34960,21 +34960,21 @@
       }));
     });
   }
-  var isArray$2 = Array.isArray;
+  var isArray$3 = Array.isArray;
   function callOrApply(fn, args) {
-    return isArray$2(args) ? fn.apply(void 0, __spreadArray([], __read$1(args))) : fn(args);
+    return isArray$3(args) ? fn.apply(void 0, __spreadArray([], __read$1(args))) : fn(args);
   }
   function mapOneOrManyArgs(fn) {
     return map$1(function(args) {
       return callOrApply(fn, args);
     });
   }
-  var isArray$1 = Array.isArray;
-  var getPrototypeOf$1 = Object.getPrototypeOf, objectProto = Object.prototype, getKeys = Object.keys;
+  var isArray$2 = Array.isArray;
+  var getPrototypeOf$2 = Object.getPrototypeOf, objectProto = Object.prototype, getKeys = Object.keys;
   function argsArgArrayOrObject(args) {
     if (args.length === 1) {
       var first_1 = args[0];
-      if (isArray$1(first_1)) {
+      if (isArray$2(first_1)) {
         return { args: first_1, keys: null };
       }
       if (isPOJO(first_1)) {
@@ -34990,7 +34990,7 @@
     return { args, keys: null };
   }
   function isPOJO(obj) {
-    return obj && typeof obj === "object" && getPrototypeOf$1(obj) === objectProto;
+    return obj && typeof obj === "object" && getPrototypeOf$2(obj) === objectProto;
   }
   function createObject(keys, values) {
     return keys.reduce(function(result, key, i2) {
@@ -35115,7 +35115,7 @@
     if (concurrent === void 0) {
       concurrent = Infinity;
     }
-    if (isFunction$1(resultSelector)) {
+    if (isFunction$2(resultSelector)) {
       return mergeMap(function(a2, i2) {
         return map$1(function(b2, ii) {
           return resultSelector(a2, b2, i2, ii);
@@ -35148,7 +35148,7 @@
   var eventTargetMethods = ["addEventListener", "removeEventListener"];
   var jqueryMethods = ["on", "off"];
   function fromEvent(target2, eventName, options, resultSelector) {
-    if (isFunction$1(options)) {
+    if (isFunction$2(options)) {
       resultSelector = options;
       options = void 0;
     }
@@ -35192,13 +35192,13 @@
     };
   }
   function isNodeStyleEventEmitter(target2) {
-    return isFunction$1(target2.addListener) && isFunction$1(target2.removeListener);
+    return isFunction$2(target2.addListener) && isFunction$2(target2.removeListener);
   }
   function isJQueryStyleEventEmitter(target2) {
-    return isFunction$1(target2.on) && isFunction$1(target2.off);
+    return isFunction$2(target2.on) && isFunction$2(target2.off);
   }
   function isEventTarget(target2) {
-    return isFunction$1(target2.addEventListener) && isFunction$1(target2.removeEventListener);
+    return isFunction$2(target2.addEventListener) && isFunction$2(target2.removeEventListener);
   }
   function timer(dueTime, intervalOrScheduler, scheduler2) {
     if (dueTime === void 0) {
@@ -35298,7 +35298,7 @@
     return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true));
   }
   function concatMap(project, resultSelector) {
-    return isFunction$1(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
+    return isFunction$2(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
   }
   function defaultIfEmpty(defaultValue) {
     return operate(function(source, subscriber) {
@@ -35367,7 +35367,7 @@
   function defaultErrorFactory() {
     return new EmptyError();
   }
-  function finalize$1(callback) {
+  function finalize$2(callback) {
     return operate(function(source, subscriber) {
       try {
         source.subscribe(subscriber);
@@ -35597,7 +35597,7 @@
     });
   }
   function tap(observerOrNext, error2, complete) {
-    var tapObserver = isFunction$1(observerOrNext) || error2 || complete ? { next: observerOrNext, error: error2, complete } : observerOrNext;
+    var tapObserver = isFunction$2(observerOrNext) || error2 || complete ? { next: observerOrNext, error: error2, complete } : observerOrNext;
     return tapObserver ? operate(function(source, subscriber) {
       var _a;
       (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
@@ -37705,7 +37705,7 @@
       return false;
     }
   });
-  function isPlainObject$3(o2) {
+  function isPlainObject$4(o2) {
     if (isObject$1(o2) === false)
       return false;
     const ctor = o2.constructor;
@@ -37720,7 +37720,7 @@
     return true;
   }
   function shallowClone(o2) {
-    if (isPlainObject$3(o2))
+    if (isPlainObject$4(o2))
       return { ...o2 };
     if (Array.isArray(o2))
       return [...o2];
@@ -37903,7 +37903,7 @@
     return clone$1(schema, def);
   }
   function extend(schema, shape2) {
-    if (!isPlainObject$3(shape2)) {
+    if (!isPlainObject$4(shape2)) {
       throw new Error("Invalid input to extend: expected a plain object");
     }
     const checks = schema._zod.def.checks;
@@ -37922,7 +37922,7 @@
     return clone$1(schema, def);
   }
   function safeExtend(schema, shape2) {
-    if (!isPlainObject$3(shape2)) {
+    if (!isPlainObject$4(shape2)) {
       throw new Error("Invalid input to safeExtend: expected a plain object");
     }
     const def = {
@@ -38158,7 +38158,7 @@
     getSizableOrigin,
     hexToUint8Array,
     isObject: isObject$1,
-    isPlainObject: isPlainObject$3,
+    isPlainObject: isPlainObject$4,
     issue,
     joinValues,
     jsonStringifyReplacer,
@@ -40133,7 +40133,7 @@
     if (a2 instanceof Date && b2 instanceof Date && +a2 === +b2) {
       return { valid: true, data: a2 };
     }
-    if (isPlainObject$3(a2) && isPlainObject$3(b2)) {
+    if (isPlainObject$4(a2) && isPlainObject$4(b2)) {
       const bKeys = Object.keys(b2);
       const sharedKeys = Object.keys(a2).filter((key) => bKeys.indexOf(key) !== -1);
       const newObj = { ...a2, ...b2 };
@@ -40263,7 +40263,7 @@
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isPlainObject$3(input)) {
+      if (!isPlainObject$4(input)) {
         payload.issues.push({
           expected: "record",
           code: "invalid_type",
@@ -43304,7 +43304,7 @@
       }
     };
   };
-  function is$1() {
+  function is$2() {
     return {
       localeError: error$u()
     };
@@ -46519,7 +46519,7 @@
     he: he$1,
     hu,
     id,
-    is: is$1,
+    is: is$2,
     it,
     ja,
     ka,
@@ -49259,7 +49259,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.max = (...args) => inst.check(_maxSize(...args));
     inst.size = (...args) => inst.check(_size(...args));
   });
-  function set$2(valueType, params) {
+  function set$3(valueType, params) {
     return new ZodSet({
       type: "set",
       valueType,
@@ -49855,7 +49855,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     safeEncodeAsync,
     safeParse,
     safeParseAsync,
-    set: set$2,
+    set: set$3,
     setErrorMap,
     size: _size,
     startsWith: _startsWith,
@@ -50304,7 +50304,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       })).pipe(
         // Stop reading if the abort signal is triggered
         takeUntil(options?.abortSignal ? fromEvent(options.abortSignal, "abort") : EMPTY),
-        finalize$1(async () => {
+        finalize$2(async () => {
           await reader.cancel().catch(() => {
           });
           reader.releaseLock();
@@ -50671,10 +50671,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       config2.configureClient(name2, args);
     }
   });
-  var NOTHING = /* @__PURE__ */ Symbol.for("immer-nothing");
-  var DRAFTABLE = /* @__PURE__ */ Symbol.for("immer-draftable");
-  var DRAFT_STATE = /* @__PURE__ */ Symbol.for("immer-state");
-  var errors = process.env.NODE_ENV !== "production" ? [
+  var NOTHING$1 = /* @__PURE__ */ Symbol.for("immer-nothing");
+  var DRAFTABLE$1 = /* @__PURE__ */ Symbol.for("immer-draftable");
+  var DRAFT_STATE$1 = /* @__PURE__ */ Symbol.for("immer-state");
+  var errors$1 = process.env.NODE_ENV !== "production" ? [
     // All error codes, starting by 0:
     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.`;
@@ -50705,48 +50705,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     // Note: if more errors are added, the errorOffset in Patches.ts should be increased
     // See Patches.ts for additional errors
   ] : [];
-  function die(error2, ...args) {
+  function die$1(error2, ...args) {
     if (process.env.NODE_ENV !== "production") {
-      const e2 = errors[error2];
-      const msg = typeof e2 === "function" ? e2.apply(null, args) : e2;
+      const e2 = errors$1[error2];
+      const msg = isFunction$1(e2) ? e2.apply(null, args) : e2;
       throw new Error(`[Immer] ${msg}`);
     }
     throw new Error(
       `[Immer] minified error nr: ${error2}. Full error at: https://bit.ly/3cXEKWf`
     );
   }
-  var getPrototypeOf = Object.getPrototypeOf;
-  function isDraft(value) {
-    return !!value && !!value[DRAFT_STATE];
-  }
-  function isDraftable(value) {
+  var O$1 = Object;
+  var getPrototypeOf$1 = O$1.getPrototypeOf;
+  var CONSTRUCTOR = "constructor";
+  var PROTOTYPE = "prototype";
+  var CONFIGURABLE = "configurable";
+  var ENUMERABLE = "enumerable";
+  var WRITABLE = "writable";
+  var VALUE = "value";
+  var isDraft$1 = (value) => !!value && !!value[DRAFT_STATE$1];
+  function isDraftable$1(value) {
     if (!value)
       return false;
-    return isPlainObject$2(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap$1(value) || isSet$1(value);
+    return isPlainObject$3(value) || isArray$1(value) || !!value[DRAFTABLE$1] || !!value[CONSTRUCTOR]?.[DRAFTABLE$1] || isMap$2(value) || isSet$2(value);
   }
-  var objectCtorString = Object.prototype.constructor.toString();
-  var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
-  function isPlainObject$2(value) {
-    if (!value || typeof value !== "object")
+  var objectCtorString$1 = O$1[PROTOTYPE][CONSTRUCTOR].toString();
+  var cachedCtorStrings$1 = /* @__PURE__ */ new WeakMap();
+  function isPlainObject$3(value) {
+    if (!value || !isObjectish(value))
       return false;
-    const proto = Object.getPrototypeOf(value);
-    if (proto === null || proto === Object.prototype)
+    const proto = getPrototypeOf$1(value);
+    if (proto === null || proto === O$1[PROTOTYPE])
       return true;
-    const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+    const Ctor = O$1.hasOwnProperty.call(proto, CONSTRUCTOR) && proto[CONSTRUCTOR];
     if (Ctor === Object)
       return true;
-    if (typeof Ctor !== "function")
+    if (!isFunction$1(Ctor))
       return false;
-    let ctorString = cachedCtorStrings.get(Ctor);
+    let ctorString = cachedCtorStrings$1.get(Ctor);
     if (ctorString === void 0) {
       ctorString = Function.toString.call(Ctor);
-      cachedCtorStrings.set(Ctor, ctorString);
+      cachedCtorStrings$1.set(Ctor, ctorString);
     }
-    return ctorString === objectCtorString;
+    return ctorString === objectCtorString$1;
   }
-  function each(obj, iter, strict = true) {
-    if (getArchtype(obj) === 0) {
-      const keys = strict ? Reflect.ownKeys(obj) : Object.keys(obj);
+  function each$1(obj, iter, strict = true) {
+    if (getArchtype$1(obj) === 0) {
+      const keys = strict ? Reflect.ownKeys(obj) : O$1.keys(obj);
       keys.forEach((key) => {
         iter(key, obj[key], obj);
       });
@@ -50754,300 +50759,352 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       obj.forEach((entry, index2) => iter(index2, entry, obj));
     }
   }
-  function getArchtype(thing) {
-    const state = thing[DRAFT_STATE];
-    return state ? state.type_ : Array.isArray(thing) ? 1 : isMap$1(thing) ? 2 : isSet$1(thing) ? 3 : 0;
-  }
-  function has(thing, prop) {
-    return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+  function getArchtype$1(thing) {
+    const state = thing[DRAFT_STATE$1];
+    return state ? state.type_ : isArray$1(thing) ? 1 : isMap$2(thing) ? 2 : isSet$2(thing) ? 3 : 0;
   }
-  function set$1(thing, propOrOldValue, value) {
-    const t2 = getArchtype(thing);
-    if (t2 === 2)
+  var has$1 = (thing, prop, type = getArchtype$1(thing)) => type === 2 ? thing.has(prop) : O$1[PROTOTYPE].hasOwnProperty.call(thing, prop);
+  var get$2 = (thing, prop, type = getArchtype$1(thing)) => (
+    // @ts-ignore
+    type === 2 ? thing.get(prop) : thing[prop]
+  );
+  var set$2 = (thing, propOrOldValue, value, type = getArchtype$1(thing)) => {
+    if (type === 2)
       thing.set(propOrOldValue, value);
-    else if (t2 === 3) {
+    else if (type === 3) {
       thing.add(value);
     } else
       thing[propOrOldValue] = value;
-  }
-  function is(x2, y2) {
+  };
+  function is$1(x2, y2) {
     if (x2 === y2) {
       return x2 !== 0 || 1 / x2 === 1 / y2;
     } else {
       return x2 !== x2 && y2 !== y2;
     }
   }
-  function isMap$1(target2) {
-    return target2 instanceof Map;
-  }
-  function isSet$1(target2) {
-    return target2 instanceof Set;
-  }
-  function latest(state) {
-    return state.copy_ || state.base_;
-  }
-  function shallowCopy(base, strict) {
-    if (isMap$1(base)) {
+  var isArray$1 = Array.isArray;
+  var isMap$2 = (target2) => target2 instanceof Map;
+  var isSet$2 = (target2) => target2 instanceof Set;
+  var isObjectish = (target2) => typeof target2 === "object";
+  var isFunction$1 = (target2) => typeof target2 === "function";
+  var isBoolean$1 = (target2) => typeof target2 === "boolean";
+  function isArrayIndex(value) {
+    const n2 = +value;
+    return Number.isInteger(n2) && String(n2) === value;
+  }
+  var latest$1 = (state) => state.copy_ || state.base_;
+  var getFinalValue = (state) => state.modified_ ? state.copy_ : state.base_;
+  function shallowCopy$1(base, strict) {
+    if (isMap$2(base)) {
       return new Map(base);
     }
-    if (isSet$1(base)) {
+    if (isSet$2(base)) {
       return new Set(base);
     }
-    if (Array.isArray(base))
-      return Array.prototype.slice.call(base);
-    const isPlain = isPlainObject$2(base);
+    if (isArray$1(base))
+      return Array[PROTOTYPE].slice.call(base);
+    const isPlain = isPlainObject$3(base);
     if (strict === true || strict === "class_only" && !isPlain) {
-      const descriptors = Object.getOwnPropertyDescriptors(base);
-      delete descriptors[DRAFT_STATE];
+      const descriptors = O$1.getOwnPropertyDescriptors(base);
+      delete descriptors[DRAFT_STATE$1];
       let keys = Reflect.ownKeys(descriptors);
       for (let i2 = 0; i2 < keys.length; i2++) {
         const key = keys[i2];
         const desc = descriptors[key];
-        if (desc.writable === false) {
-          desc.writable = true;
-          desc.configurable = true;
+        if (desc[WRITABLE] === false) {
+          desc[WRITABLE] = true;
+          desc[CONFIGURABLE] = true;
         }
         if (desc.get || desc.set)
           descriptors[key] = {
-            configurable: true,
-            writable: true,
+            [CONFIGURABLE]: true,
+            [WRITABLE]: true,
             // could live with !!desc.set as well here...
-            enumerable: desc.enumerable,
-            value: base[key]
+            [ENUMERABLE]: desc[ENUMERABLE],
+            [VALUE]: base[key]
           };
       }
-      return Object.create(getPrototypeOf(base), descriptors);
+      return O$1.create(getPrototypeOf$1(base), descriptors);
     } else {
-      const proto = getPrototypeOf(base);
+      const proto = getPrototypeOf$1(base);
       if (proto !== null && isPlain) {
         return { ...base };
       }
-      const obj = Object.create(proto);
-      return Object.assign(obj, base);
+      const obj = O$1.create(proto);
+      return O$1.assign(obj, base);
     }
   }
-  function freeze(obj, deep = false) {
-    if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+  function freeze$1(obj, deep = false) {
+    if (isFrozen$1(obj) || isDraft$1(obj) || !isDraftable$1(obj))
       return obj;
-    if (getArchtype(obj) > 1) {
-      Object.defineProperties(obj, {
-        set: dontMutateMethodOverride,
-        add: dontMutateMethodOverride,
-        clear: dontMutateMethodOverride,
-        delete: dontMutateMethodOverride
+    if (getArchtype$1(obj) > 1) {
+      O$1.defineProperties(obj, {
+        set: dontMutateMethodOverride$1,
+        add: dontMutateMethodOverride$1,
+        clear: dontMutateMethodOverride$1,
+        delete: dontMutateMethodOverride$1
       });
     }
-    Object.freeze(obj);
+    O$1.freeze(obj);
     if (deep)
-      Object.values(obj).forEach((value) => freeze(value, true));
+      each$1(
+        obj,
+        (_key, value) => {
+          freeze$1(value, true);
+        },
+        false
+      );
     return obj;
   }
-  function dontMutateFrozenCollections() {
-    die(2);
+  function dontMutateFrozenCollections$1() {
+    die$1(2);
   }
-  var dontMutateMethodOverride = {
-    value: dontMutateFrozenCollections
+  var dontMutateMethodOverride$1 = {
+    [VALUE]: dontMutateFrozenCollections$1
   };
-  function isFrozen(obj) {
-    if (obj === null || typeof obj !== "object")
+  function isFrozen$1(obj) {
+    if (obj === null || !isObjectish(obj))
       return true;
-    return Object.isFrozen(obj);
-  }
-  var plugins = {};
-  function getPlugin(pluginKey) {
-    const plugin = plugins[pluginKey];
+    return O$1.isFrozen(obj);
+  }
+  var PluginMapSet = "MapSet";
+  var PluginPatches = "Patches";
+  var PluginArrayMethods = "ArrayMethods";
+  var plugins$1 = {};
+  function getPlugin$1(pluginKey) {
+    const plugin = plugins$1[pluginKey];
     if (!plugin) {
-      die(0, pluginKey);
+      die$1(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_,
-      // Whenever the modified draft contains a draft from another scope, we
-      // need to prevent auto-freezing so the unowned draft can be finalized.
-      canAutoFreeze_: true,
-      unfinalizedDrafts_: 0
-    };
-  }
-  function usePatchesInScope(scope, patchListener) {
+  var isPluginLoaded = (pluginKey) => !!plugins$1[pluginKey];
+  var currentScope$1;
+  var getCurrentScope$1 = () => currentScope$1;
+  var createScope$1 = (parent_, immer_) => ({
+    drafts_: [],
+    parent_,
+    immer_,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: true,
+    unfinalizedDrafts_: 0,
+    handledSet_: /* @__PURE__ */ new Set(),
+    processedForPatches_: /* @__PURE__ */ new Set(),
+    mapSetPlugin_: isPluginLoaded(PluginMapSet) ? getPlugin$1(PluginMapSet) : void 0,
+    arrayMethodsPlugin_: isPluginLoaded(PluginArrayMethods) ? getPlugin$1(PluginArrayMethods) : void 0
+  });
+  function usePatchesInScope$1(scope, patchListener) {
     if (patchListener) {
-      getPlugin("Patches");
+      scope.patchPlugin_ = getPlugin$1(PluginPatches);
       scope.patches_ = [];
       scope.inversePatches_ = [];
       scope.patchListener_ = patchListener;
     }
   }
-  function revokeScope(scope) {
-    leaveScope(scope);
-    scope.drafts_.forEach(revokeDraft);
+  function revokeScope$1(scope) {
+    leaveScope$1(scope);
+    scope.drafts_.forEach(revokeDraft$1);
     scope.drafts_ = null;
   }
-  function leaveScope(scope) {
-    if (scope === currentScope) {
-      currentScope = scope.parent_;
+  function leaveScope$1(scope) {
+    if (scope === currentScope$1) {
+      currentScope$1 = scope.parent_;
     }
   }
-  function enterScope(immer2) {
-    return currentScope = createScope(currentScope, immer2);
-  }
-  function revokeDraft(draft) {
-    const state = draft[DRAFT_STATE];
+  var enterScope$1 = (immer2) => currentScope$1 = createScope$1(currentScope$1, immer2);
+  function revokeDraft$1(draft) {
+    const state = draft[DRAFT_STATE$1];
     if (state.type_ === 0 || state.type_ === 1)
       state.revoke_();
     else
       state.revoked_ = true;
   }
-  function processResult(result, scope) {
+  function processResult$1(result, scope) {
     scope.unfinalizedDrafts_ = scope.drafts_.length;
     const baseDraft = scope.drafts_[0];
     const isReplaced = result !== void 0 && result !== baseDraft;
     if (isReplaced) {
-      if (baseDraft[DRAFT_STATE].modified_) {
-        revokeScope(scope);
-        die(4);
+      if (baseDraft[DRAFT_STATE$1].modified_) {
+        revokeScope$1(scope);
+        die$1(4);
       }
-      if (isDraftable(result)) {
-        result = finalize(scope, result);
-        if (!scope.parent_)
-          maybeFreeze(scope, result);
+      if (isDraftable$1(result)) {
+        result = finalize$1(scope, result);
       }
-      if (scope.patches_) {
-        getPlugin("Patches").generateReplacementPatches_(
-          baseDraft[DRAFT_STATE].base_,
+      const { patchPlugin_ } = scope;
+      if (patchPlugin_) {
+        patchPlugin_.generateReplacementPatches_(
+          baseDraft[DRAFT_STATE$1].base_,
           result,
-          scope.patches_,
-          scope.inversePatches_
+          scope
         );
       }
     } else {
-      result = finalize(scope, baseDraft, []);
+      result = finalize$1(scope, baseDraft);
     }
-    revokeScope(scope);
+    maybeFreeze$1(scope, result, true);
+    revokeScope$1(scope);
     if (scope.patches_) {
       scope.patchListener_(scope.patches_, scope.inversePatches_);
     }
-    return result !== NOTHING ? result : void 0;
+    return result !== NOTHING$1 ? result : void 0;
   }
-  function finalize(rootScope, value, path) {
-    if (isFrozen(value))
+  function finalize$1(rootScope, value) {
+    if (isFrozen$1(value))
       return value;
-    const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
-    const state = value[DRAFT_STATE];
+    const state = value[DRAFT_STATE$1];
     if (!state) {
-      each(
-        value,
-        (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path),
-        useStrictIteration
-      );
-      return value;
+      const finalValue = handleValue(value, rootScope.handledSet_, rootScope);
+      return finalValue;
     }
-    if (state.scope_ !== rootScope)
+    if (!isSameScope(state, 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_
-        );
+      const { callbacks_ } = state;
+      if (callbacks_) {
+        while (callbacks_.length > 0) {
+          const callback = callbacks_.pop();
+          callback(rootScope);
+        }
       }
+      generatePatchesAndFinalize(state, rootScope);
     }
     return state.copy_;
   }
-  function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
-    if (childValue == null) {
-      return;
-    }
-    if (typeof childValue !== "object" && !targetIsSet) {
-      return;
+  function maybeFreeze$1(scope, value, deep = false) {
+    if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+      freeze$1(value, deep);
+    }
+  }
+  function markStateFinalized(state) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+  }
+  var isSameScope = (state, rootScope) => state.scope_ === rootScope;
+  var EMPTY_LOCATIONS_RESULT = [];
+  function updateDraftInParent(parent, draftValue, finalizedValue, originalKey) {
+    const parentCopy = latest$1(parent);
+    const parentType = parent.type_;
+    if (originalKey !== void 0) {
+      const currentValue = get$2(parentCopy, originalKey, parentType);
+      if (currentValue === draftValue) {
+        set$2(parentCopy, originalKey, finalizedValue, parentType);
+        return;
+      }
     }
-    const childIsFrozen = isFrozen(childValue);
-    if (childIsFrozen && !targetIsSet) {
-      return;
+    if (!parent.draftLocations_) {
+      const draftLocations = parent.draftLocations_ = /* @__PURE__ */ new Map();
+      each$1(parentCopy, (key, value) => {
+        if (isDraft$1(value)) {
+          const keys = draftLocations.get(value) || [];
+          keys.push(key);
+          draftLocations.set(value, keys);
+        }
+      });
     }
-    if (process.env.NODE_ENV !== "production" && childValue === targetObject)
-      die(5);
-    if (isDraft(childValue)) {
-      const path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
-      !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
-      const res = finalize(rootScope, childValue, path);
-      set$1(targetObject, prop, res);
-      if (isDraft(res)) {
-        rootScope.canAutoFreeze_ = false;
-      } else
-        return;
-    } else if (targetIsSet) {
-      targetObject.add(childValue);
+    const locations = parent.draftLocations_.get(draftValue) ?? EMPTY_LOCATIONS_RESULT;
+    for (const location of locations) {
+      set$2(parentCopy, location, finalizedValue, parentType);
     }
-    if (isDraftable(childValue) && !childIsFrozen) {
-      if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+  }
+  function registerChildFinalizationCallback(parent, child, key) {
+    parent.callbacks_.push(function childCleanup(rootScope) {
+      const state = child;
+      if (!state || !isSameScope(state, rootScope)) {
         return;
       }
-      if (parentState && parentState.base_ && parentState.base_[prop] === childValue && childIsFrozen) {
-        return;
+      rootScope.mapSetPlugin_?.fixSetContents(state);
+      const finalizedValue = getFinalValue(state);
+      updateDraftInParent(parent, state.draft_ ?? state, finalizedValue, key);
+      generatePatchesAndFinalize(state, rootScope);
+    });
+  }
+  function generatePatchesAndFinalize(state, rootScope) {
+    const shouldFinalize = state.modified_ && !state.finalized_ && (state.type_ === 3 || state.type_ === 1 && state.allIndicesReassigned_ || (state.assigned_?.size ?? 0) > 0);
+    if (shouldFinalize) {
+      const { patchPlugin_ } = rootScope;
+      if (patchPlugin_) {
+        const basePath = patchPlugin_.getPath(state);
+        if (basePath) {
+          patchPlugin_.generatePatches_(state, basePath, rootScope);
+        }
       }
-      finalize(rootScope, childValue);
-      if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap$1(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop)))
-        maybeFreeze(rootScope, childValue);
+      markStateFinalized(state);
     }
   }
-  function maybeFreeze(scope, value, deep = false) {
-    if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
-      freeze(value, deep);
+  function handleCrossReference(target2, key, value) {
+    const { scope_ } = target2;
+    if (isDraft$1(value)) {
+      const state = value[DRAFT_STATE$1];
+      if (isSameScope(state, scope_)) {
+        state.callbacks_.push(function crossReferenceCleanup() {
+          prepareCopy$1(target2);
+          const finalizedValue = getFinalValue(state);
+          updateDraftInParent(target2, value, finalizedValue, key);
+        });
+      }
+    } else if (isDraftable$1(value)) {
+      target2.callbacks_.push(function nestedDraftCleanup() {
+        const targetCopy = latest$1(target2);
+        if (target2.type_ === 3) {
+          if (targetCopy.has(value)) {
+            handleValue(value, scope_.handledSet_, scope_);
+          }
+        } else {
+          if (get$2(targetCopy, key, target2.type_) === value) {
+            if (scope_.drafts_.length > 1 && (target2.assigned_.get(key) ?? false) === true && target2.copy_) {
+              handleValue(
+                get$2(target2.copy_, key, target2.type_),
+                scope_.handledSet_,
+                scope_
+              );
+            }
+          }
+        }
+      });
     }
   }
-  function createProxyProxy(base, parent) {
-    const isArray3 = Array.isArray(base);
+  function handleValue(target2, handledSet, rootScope) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return target2;
+    }
+    if (isDraft$1(target2) || handledSet.has(target2) || !isDraftable$1(target2) || isFrozen$1(target2)) {
+      return target2;
+    }
+    handledSet.add(target2);
+    each$1(target2, (key, value) => {
+      if (isDraft$1(value)) {
+        const state = value[DRAFT_STATE$1];
+        if (isSameScope(state, rootScope)) {
+          const updatedValue = getFinalValue(state);
+          set$2(target2, key, updatedValue, target2.type_);
+          markStateFinalized(state);
+        }
+      } else if (isDraftable$1(value)) {
+        handleValue(value, handledSet, rootScope);
+      }
+    });
+    return target2;
+  }
+  function createProxyProxy$1(base, parent) {
+    const baseIsArray = isArray$1(base);
     const state = {
-      type_: isArray3 ? 1 : 0,
+      type_: baseIsArray ? 1 : 0,
       // Track which produce call this is associated with.
-      scope_: parent ? parent.scope_ : getCurrentScope(),
+      scope_: parent ? parent.scope_ : getCurrentScope$1(),
       // True for both shallow and deep changes.
       modified_: false,
       // Used during finalization.
       finalized_: false,
       // Track which properties have been assigned (true) or deleted (false).
-      assigned_: {},
+      // actually instantiated in `prepareCopy()`
+      assigned_: void 0,
       // The parent draft state.
       parent_: parent,
       // The base state.
@@ -51059,77 +51116,94 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       copy_: null,
       // Called by the `produce` function.
       revoke_: null,
-      isManual_: false
+      isManual_: false,
+      // `callbacks` actually gets assigned in `createProxy`
+      callbacks_: void 0
     };
     let target2 = state;
-    let traps = objectTraps;
-    if (isArray3) {
+    let traps = objectTraps$1;
+    if (baseIsArray) {
       target2 = [state];
-      traps = arrayTraps;
+      traps = arrayTraps$1;
     }
     const { revoke, proxy } = Proxy.revocable(target2, traps);
     state.draft_ = proxy;
     state.revoke_ = revoke;
-    return proxy;
+    return [proxy, state];
   }
-  var objectTraps = {
+  var objectTraps$1 = {
     get(state, prop) {
-      if (prop === DRAFT_STATE)
+      if (prop === DRAFT_STATE$1)
         return state;
-      const source = latest(state);
-      if (!has(source, prop)) {
-        return readPropFromProto(state, source, prop);
+      let arrayPlugin = state.scope_.arrayMethodsPlugin_;
+      const isArrayWithStringProp = state.type_ === 1 && typeof prop === "string";
+      if (isArrayWithStringProp) {
+        if (arrayPlugin?.isArrayOperationMethod(prop)) {
+          return arrayPlugin.createMethodInterceptor(state, prop);
+        }
+      }
+      const source = latest$1(state);
+      if (!has$1(source, prop, state.type_)) {
+        return readPropFromProto$1(state, source, prop);
       }
       const value = source[prop];
-      if (state.finalized_ || !isDraftable(value)) {
+      if (state.finalized_ || !isDraftable$1(value)) {
         return value;
       }
-      if (value === peek$1(state.base_, prop)) {
-        prepareCopy(state);
-        return state.copy_[prop] = createProxy(value, state);
+      if (isArrayWithStringProp && state.operationMethod && arrayPlugin?.isMutatingArrayMethod(
+        state.operationMethod
+      ) && isArrayIndex(prop)) {
+        return value;
+      }
+      if (value === peek$2(state.base_, prop)) {
+        prepareCopy$1(state);
+        const childKey = state.type_ === 1 ? +prop : prop;
+        const childDraft = createProxy$1(state.scope_, value, state, childKey);
+        return state.copy_[childKey] = childDraft;
       }
       return value;
     },
     has(state, prop) {
-      return prop in latest(state);
+      return prop in latest$1(state);
     },
     ownKeys(state) {
-      return Reflect.ownKeys(latest(state));
+      return Reflect.ownKeys(latest$1(state));
     },
     set(state, prop, value) {
-      const desc = getDescriptorFromProto(latest(state), prop);
+      const desc = getDescriptorFromProto$1(latest$1(state), prop);
       if (desc?.set) {
         desc.set.call(state.draft_, value);
         return true;
       }
       if (!state.modified_) {
-        const current2 = peek$1(latest(state), prop);
-        const currentState = current2?.[DRAFT_STATE];
+        const current2 = peek$2(latest$1(state), prop);
+        const currentState = current2?.[DRAFT_STATE$1];
         if (currentState && currentState.base_ === value) {
           state.copy_[prop] = value;
-          state.assigned_[prop] = false;
+          state.assigned_.set(prop, false);
           return true;
         }
-        if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+        if (is$1(value, current2) && (value !== void 0 || has$1(state.base_, prop, state.type_)))
           return true;
-        prepareCopy(state);
-        markChanged(state);
+        prepareCopy$1(state);
+        markChanged$1(state);
       }
       if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
       (value !== void 0 || prop in state.copy_) || // special case: NaN
       Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
         return true;
       state.copy_[prop] = value;
-      state.assigned_[prop] = true;
+      state.assigned_.set(prop, true);
+      handleCrossReference(state, prop, value);
       return true;
     },
     deleteProperty(state, prop) {
-      if (peek$1(state.base_, prop) !== void 0 || prop in state.base_) {
-        state.assigned_[prop] = false;
-        prepareCopy(state);
-        markChanged(state);
+      prepareCopy$1(state);
+      if (peek$2(state.base_, prop) !== void 0 || prop in state.base_) {
+        state.assigned_.set(prop, false);
+        markChanged$1(state);
       } else {
-        delete state.assigned_[prop];
+        state.assigned_.delete(prop);
       }
       if (state.copy_) {
         delete state.copy_[prop];
@@ -51139,92 +51213,95 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     // Note: We never coerce `desc.value` into an Immer draft, because we can't make
     // the same guarantee in ES5 mode.
     getOwnPropertyDescriptor(state, prop) {
-      const owner = latest(state);
+      const owner = latest$1(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]
+        [WRITABLE]: true,
+        [CONFIGURABLE]: state.type_ !== 1 || prop !== "length",
+        [ENUMERABLE]: desc[ENUMERABLE],
+        [VALUE]: owner[prop]
       };
     },
     defineProperty() {
-      die(11);
+      die$1(11);
     },
     getPrototypeOf(state) {
-      return getPrototypeOf(state.base_);
+      return getPrototypeOf$1(state.base_);
     },
     setPrototypeOf() {
-      die(12);
+      die$1(12);
     }
   };
-  var arrayTraps = {};
-  each(objectTraps, (key, fn) => {
-    arrayTraps[key] = function() {
-      arguments[0] = arguments[0][0];
-      return fn.apply(this, arguments);
+  var arrayTraps$1 = {};
+  for (let key in objectTraps$1) {
+    let fn = objectTraps$1[key];
+    arrayTraps$1[key] = function() {
+      const args = arguments;
+      args[0] = args[0][0];
+      return fn.apply(this, args);
     };
-  });
-  arrayTraps.deleteProperty = function(state, prop) {
+  }
+  arrayTraps$1.deleteProperty = function(state, prop) {
     if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
-      die(13);
-    return arrayTraps.set.call(this, state, prop, void 0);
+      die$1(13);
+    return arrayTraps$1.set.call(this, state, prop, void 0);
   };
-  arrayTraps.set = function(state, prop, value) {
+  arrayTraps$1.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]);
+      die$1(14);
+    return objectTraps$1.set.call(this, state[0], prop, value, state[0]);
   };
-  function peek$1(draft, prop) {
-    const state = draft[DRAFT_STATE];
-    const source = state ? latest(state) : draft;
+  function peek$2(draft, prop) {
+    const state = draft[DRAFT_STATE$1];
+    const source = state ? latest$1(state) : draft;
     return source[prop];
   }
-  function readPropFromProto(state, source, prop) {
-    const desc = getDescriptorFromProto(source, prop);
-    return desc ? `value` in desc ? desc.value : (
+  function readPropFromProto$1(state, source, prop) {
+    const desc = getDescriptorFromProto$1(source, prop);
+    return desc ? VALUE in desc ? desc[VALUE] : (
       // This is a very special case, if the prop is a getter defined by the
       // prototype, we should invoke it with the draft as context!
       desc.get?.call(state.draft_)
     ) : void 0;
   }
-  function getDescriptorFromProto(source, prop) {
+  function getDescriptorFromProto$1(source, prop) {
     if (!(prop in source))
       return void 0;
-    let proto = getPrototypeOf(source);
+    let proto = getPrototypeOf$1(source);
     while (proto) {
       const desc = Object.getOwnPropertyDescriptor(proto, prop);
       if (desc)
         return desc;
-      proto = getPrototypeOf(proto);
+      proto = getPrototypeOf$1(proto);
     }
     return void 0;
   }
-  function markChanged(state) {
+  function markChanged$1(state) {
     if (!state.modified_) {
       state.modified_ = true;
       if (state.parent_) {
-        markChanged(state.parent_);
+        markChanged$1(state.parent_);
       }
     }
   }
-  function prepareCopy(state) {
+  function prepareCopy$1(state) {
     if (!state.copy_) {
-      state.copy_ = shallowCopy(
+      state.assigned_ = /* @__PURE__ */ new Map();
+      state.copy_ = shallowCopy$1(
         state.base_,
         state.scope_.immer_.useStrictShallowCopy_
       );
     }
   }
-  var Immer2 = class {
+  var Immer2$1 = class Immer2 {
     constructor(config2) {
       this.autoFreeze_ = true;
       this.useStrictShallowCopy_ = false;
-      this.useStrictIteration_ = true;
+      this.useStrictIteration_ = false;
       this.produce = (base, recipe, patchListener) => {
-        if (typeof base === "function" && typeof recipe !== "function") {
+        if (isFunction$1(base) && !isFunction$1(recipe)) {
           const defaultBase = recipe;
           recipe = base;
           const self2 = this;
@@ -51232,46 +51309,49 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             return self2.produce(base2, (draft) => recipe.call(this, draft, ...args));
           };
         }
-        if (typeof recipe !== "function")
-          die(6);
-        if (patchListener !== void 0 && typeof patchListener !== "function")
-          die(7);
+        if (!isFunction$1(recipe))
+          die$1(6);
+        if (patchListener !== void 0 && !isFunction$1(patchListener))
+          die$1(7);
         let result;
-        if (isDraftable(base)) {
-          const scope = enterScope(this);
-          const proxy = createProxy(base, void 0);
+        if (isDraftable$1(base)) {
+          const scope = enterScope$1(this);
+          const proxy = createProxy$1(scope, base, void 0);
           let hasError = true;
           try {
             result = recipe(proxy);
             hasError = false;
           } finally {
             if (hasError)
-              revokeScope(scope);
+              revokeScope$1(scope);
             else
-              leaveScope(scope);
+              leaveScope$1(scope);
           }
-          usePatchesInScope(scope, patchListener);
-          return processResult(result, scope);
-        } else if (!base || typeof base !== "object") {
+          usePatchesInScope$1(scope, patchListener);
+          return processResult$1(result, scope);
+        } else if (!base || !isObjectish(base)) {
           result = recipe(base);
           if (result === void 0)
             result = base;
-          if (result === NOTHING)
+          if (result === NOTHING$1)
             result = void 0;
           if (this.autoFreeze_)
-            freeze(result, true);
+            freeze$1(result, true);
           if (patchListener) {
             const p2 = [];
             const ip = [];
-            getPlugin("Patches").generateReplacementPatches_(base, result, p2, ip);
+            getPlugin$1(PluginPatches).generateReplacementPatches_(base, result, {
+              patches_: p2,
+              inversePatches_: ip
+            });
             patchListener(p2, ip);
           }
           return result;
         } else
-          die(1, base);
+          die$1(1, base);
       };
       this.produceWithPatches = (base, recipe) => {
-        if (typeof base === "function") {
+        if (isFunction$1(base)) {
           return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
         }
         let patches, inversePatches;
@@ -51281,31 +51361,31 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         });
         return [result, patches, inversePatches];
       };
-      if (typeof config2?.autoFreeze === "boolean")
+      if (isBoolean$1(config2?.autoFreeze))
         this.setAutoFreeze(config2.autoFreeze);
-      if (typeof config2?.useStrictShallowCopy === "boolean")
+      if (isBoolean$1(config2?.useStrictShallowCopy))
         this.setUseStrictShallowCopy(config2.useStrictShallowCopy);
-      if (typeof config2?.useStrictIteration === "boolean")
+      if (isBoolean$1(config2?.useStrictIteration))
         this.setUseStrictIteration(config2.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);
+      if (!isDraftable$1(base))
+        die$1(8);
+      if (isDraft$1(base))
+        base = current$1(base);
+      const scope = enterScope$1(this);
+      const proxy = createProxy$1(scope, base, void 0);
+      proxy[DRAFT_STATE$1].isManual_ = true;
+      leaveScope$1(scope);
       return proxy;
     }
     finishDraft(draft, patchListener) {
-      const state = draft && draft[DRAFT_STATE];
+      const state = draft && draft[DRAFT_STATE$1];
       if (!state || !state.isManual_)
-        die(9);
+        die$1(9);
       const { scope_: scope } = state;
-      usePatchesInScope(scope, patchListener);
-      return processResult(void 0, scope);
+      usePatchesInScope$1(scope, patchListener);
+      return processResult$1(void 0, scope);
     }
     /**
      * Pass true to automatically freeze all copies created by Immer.
@@ -51347,8 +51427,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (i2 > -1) {
         patches = patches.slice(i2 + 1);
       }
-      const applyPatchesImpl = getPlugin("Patches").applyPatches_;
-      if (isDraft(base)) {
+      const applyPatchesImpl = getPlugin$1(PluginPatches).applyPatches_;
+      if (isDraft$1(base)) {
         return applyPatchesImpl(base, patches);
       }
       return this.produce(
@@ -51357,36 +51437,49 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       );
     }
   };
-  function createProxy(value, parent) {
-    const draft = isMap$1(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet$1(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
-    const scope = parent ? parent.scope_ : getCurrentScope();
+  function createProxy$1(rootScope, value, parent, key) {
+    const [draft, state] = isMap$2(value) ? getPlugin$1(PluginMapSet).proxyMap_(value, parent) : isSet$2(value) ? getPlugin$1(PluginMapSet).proxySet_(value, parent) : createProxyProxy$1(value, parent);
+    const scope = parent?.scope_ ?? getCurrentScope$1();
     scope.drafts_.push(draft);
+    state.callbacks_ = parent?.callbacks_ ?? [];
+    state.key_ = key;
+    if (parent && key !== void 0) {
+      registerChildFinalizationCallback(parent, state, key);
+    } else {
+      state.callbacks_.push(function rootDraftCleanup(rootScope2) {
+        rootScope2.mapSetPlugin_?.fixSetContents(state);
+        const { patchPlugin_ } = rootScope2;
+        if (state.modified_ && patchPlugin_) {
+          patchPlugin_.generatePatches_(state, [], rootScope2);
+        }
+      });
+    }
     return draft;
   }
-  function current(value) {
-    if (!isDraft(value))
-      die(10, value);
-    return currentImpl(value);
+  function current$1(value) {
+    if (!isDraft$1(value))
+      die$1(10, value);
+    return currentImpl$1(value);
   }
-  function currentImpl(value) {
-    if (!isDraftable(value) || isFrozen(value))
+  function currentImpl$1(value) {
+    if (!isDraftable$1(value) || isFrozen$1(value))
       return value;
-    const state = value[DRAFT_STATE];
+    const state = value[DRAFT_STATE$1];
     let copy2;
     let strict = true;
     if (state) {
       if (!state.modified_)
         return state.base_;
       state.finalized_ = true;
-      copy2 = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+      copy2 = shallowCopy$1(value, state.scope_.immer_.useStrictShallowCopy_);
       strict = state.scope_.immer_.shouldUseStrictIteration();
     } else {
-      copy2 = shallowCopy(value, true);
+      copy2 = shallowCopy$1(value, true);
     }
-    each(
+    each$1(
       copy2,
       (key, childValue) => {
-        set$1(copy2, key, currentImpl(childValue));
+        set$2(copy2, key, currentImpl$1(childValue));
       },
       strict
     );
@@ -51395,259 +51488,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     return copy2;
   }
-  function enableMapSet() {
-    class DraftMap extends Map {
-      constructor(target2, 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_: target2,
-          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, _map2) => {
-          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 iterator2 = this.keys();
-        return {
-          [Symbol.iterator]: () => this.values(),
-          next: () => {
-            const r2 = iterator2.next();
-            if (r2.done)
-              return r2;
-            const value = this.get(r2.value);
-            return {
-              done: false,
-              value
-            };
-          }
-        };
-      }
-      entries() {
-        const iterator2 = this.keys();
-        return {
-          [Symbol.iterator]: () => this.entries(),
-          next: () => {
-            const r2 = iterator2.next();
-            if (r2.done)
-              return r2;
-            const value = this.get(r2.value);
-            return {
-              done: false,
-              value: [r2.value, value]
-            };
-          }
-        };
-      }
-      [Symbol.iterator]() {
-        return this.entries();
-      }
-    }
-    function proxyMap_(target2, parent) {
-      return new DraftMap(target2, parent);
-    }
-    function prepareMapCopy(state) {
-      if (!state.copy_) {
-        state.assigned_ = /* @__PURE__ */ new Map();
-        state.copy_ = new Map(state.base_);
-      }
-    }
-    class DraftSet extends Set {
-      constructor(target2, parent) {
-        super();
-        this[DRAFT_STATE] = {
-          type_: 3,
-          parent_: parent,
-          scope_: parent ? parent.scope_ : getCurrentScope(),
-          modified_: false,
-          finalized_: false,
-          copy_: void 0,
-          base_: target2,
-          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)) : (
-          /* istanbul ignore next */
-          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 iterator2 = this.values();
-        let result = iterator2.next();
-        while (!result.done) {
-          cb.call(thisArg, result.value, result.value, this);
-          result = iterator2.next();
-        }
-      }
-    }
-    function proxySet_(target2, parent) {
-      return new DraftSet(target2, 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;
-  function castDraft(value) {
-    return value;
-  }
+  var immer$1 = new Immer2$1();
+  var produce = immer$1.produce;
+  var castDraft$1 = (value) => value;
   const filterAction = (...types) => filter$1((x2) => types.includes(x2.type));
   class FlowSubject extends Observable {
     /**
@@ -51834,7 +51677,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   const isFailureAction = (action) => isActionWithSuffix(action, "failure");
   const isCompleteAction = (action) => isSuccessAction(action) || isFailureAction(action);
   function freezeDraftable(val) {
-    return isDraftable(val) ? produce(val, () => {
+    return isDraftable$1(val) ? produce(val, () => {
     }) : val;
   }
   function isStateFunction(x2) {
@@ -51859,14 +51702,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return caseReducers.reduce((previousState, caseReducer) => {
         if (caseReducer) {
-          if (isDraft(previousState)) {
+          if (isDraft$1(previousState)) {
             const draft = previousState;
             const result = caseReducer(draft, action);
             if (result === void 0) {
               return previousState;
             }
             return result;
-          } else if (!isDraftable(previousState)) {
+          } else if (!isDraftable$1(previousState)) {
             const result = caseReducer(previousState, action);
             if (result === void 0) {
               if (previousState === null) {
@@ -52172,12 +52015,30 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this._set("parent", parent);
       return this;
     }
+    /**
+     * Attaches an observable stream of telemetry items to the configurator.
+     *
+     * @param item$ - An observable input stream of telemetry items to be processed.
+     * @returns The current instance for method chaining.
+     */
     attachItems(item$) {
       this._set("items$", item$);
       return this;
     }
+    /**
+     * Sets the filter configuration for telemetry items.
+     *
+     * The filter determines which telemetry items should be passed to adapters and/or relayed to parent providers.
+     *
+     * @param filter - Either a filter object with `adapter` and `relay` functions, or a callback that returns such a filter object.
+     * @returns The current instance for method chaining.
+     */
+    setFilter(filter2) {
+      this._set("filter", filter2);
+      return this;
+    }
   }
-  const version$9 = "4.4.0";
+  const version$9 = "4.6.3";
   var TelemetryLevel;
   (function(TelemetryLevel2) {
     TelemetryLevel2[TelemetryLevel2["Debug"] = 0] = "Debug";
@@ -52380,6 +52241,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     #items = new Subject();
     #initialized = false;
     #adapters = {};
+    #filters;
     #defaultScope;
     #eventProvider;
     get items() {
@@ -52402,6 +52264,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.#metadata = config2?.metadata;
       this.#defaultScope = config2?.defaultScope ?? [];
       this.#eventProvider = deps?.event;
+      this.#filters = config2?.filter;
     }
     /**
      * Initializes the telemetry provider with adapters, parent provider, and optional initial items.
@@ -52446,7 +52309,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      */
     async _initializeAdapters() {
       const adapterEntries = Object.entries(this.#adapters);
-      const initializationPromises = adapterEntries.map(([identifier2, adapter]) => adapter.initialize());
+      const initializationPromises = adapterEntries.map(([_identifier, adapter]) => adapter.initialize());
       const results = await Promise.allSettled(initializationPromises);
       for (const [index2, result] of results.entries()) {
         if (result.status === "rejected") {
@@ -52460,6 +52323,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * Subscribes all adapters to the telemetry item stream.
      * Each adapter processes every telemetry item as it is emitted.
+     * If an adapter filter is configured, only items that pass the filter will be sent to adapters.
      * If an adapter throws, the error is dispatched as a telemetry error event.
      *
      * @returns Subscription to the telemetry item stream
@@ -52470,6 +52334,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         throw new Error("TelemetryProvider is not initialized");
       }
       return this.#items.subscribe((item) => {
+        const { adapter: adapterFilter } = this.#filters ?? {};
+        if (adapterFilter && !adapterFilter(item)) {
+          return;
+        }
         for (const [identifier2, adapter] of Object.entries(this.#adapters)) {
           try {
             Promise.resolve(adapter.processItem(item));
@@ -52486,12 +52354,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      *
      * Subscribes to the internal telemetry item stream and forwards each processed item
      * to the specified target provider by invoking its `track` method.
+     * If a relay filter is configured, only items that pass the filter will be relayed.
      *
      * @param target - The telemetry provider to which telemetry data should be relayed.
      * @returns A Subscription object that can be used to unsubscribe from the relay.
      */
     _relayTelemetryData(target2) {
-      return this.#items.subscribe((item) => target2.track(item));
+      return this.#items.subscribe((item) => {
+        const { relay: relayFilter } = this.#filters ?? {};
+        if (relayFilter && !relayFilter(item)) {
+          return;
+        }
+        target2.track(item);
+      });
     }
     /**
      * Dispatches a telemetry event to the event provider, if available.
@@ -67724,7 +67599,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   const createReducer$2 = (initial = {}) => createReducer$3(initial, (builder) => {
     builder.addCase(actions$2.request, (state, action) => {
-      state[action.meta.transaction] = castDraft({
+      state[action.meta.transaction] = castDraft$1({
         ...action.payload,
         ...action.meta,
         execution: [],
@@ -68179,6 +68054,983 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     };
   }
   const actions$1 = createActions$1();
+  var NOTHING = /* @__PURE__ */ Symbol.for("immer-nothing");
+  var DRAFTABLE = /* @__PURE__ */ Symbol.for("immer-draftable");
+  var DRAFT_STATE = /* @__PURE__ */ Symbol.for("immer-state");
+  var errors = process.env.NODE_ENV !== "production" ? [
+    // All error codes, starting by 0:
+    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}`;
+    }
+    // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+    // See Patches.ts for additional errors
+  ] : [];
+  function die(error2, ...args) {
+    if (process.env.NODE_ENV !== "production") {
+      const e2 = errors[error2];
+      const msg = typeof e2 === "function" ? e2.apply(null, args) : e2;
+      throw new Error(`[Immer] ${msg}`);
+    }
+    throw new Error(
+      `[Immer] minified error nr: ${error2}. 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$2(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap$1(value) || isSet$1(value);
+  }
+  var objectCtorString = Object.prototype.constructor.toString();
+  var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
+  function isPlainObject$2(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) {
+      const keys = strict ? Reflect.ownKeys(obj) : Object.keys(obj);
+      keys.forEach((key) => {
+        iter(key, obj[key], obj);
+      });
+    } else {
+      obj.forEach((entry, index2) => iter(index2, entry, obj));
+    }
+  }
+  function getArchtype(thing) {
+    const state = thing[DRAFT_STATE];
+    return state ? state.type_ : Array.isArray(thing) ? 1 : isMap$1(thing) ? 2 : isSet$1(thing) ? 3 : 0;
+  }
+  function has(thing, prop) {
+    return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+  }
+  function set$1(thing, propOrOldValue, value) {
+    const t2 = getArchtype(thing);
+    if (t2 === 2)
+      thing.set(propOrOldValue, value);
+    else if (t2 === 3) {
+      thing.add(value);
+    } else
+      thing[propOrOldValue] = value;
+  }
+  function is(x2, y2) {
+    if (x2 === y2) {
+      return x2 !== 0 || 1 / x2 === 1 / y2;
+    } else {
+      return x2 !== x2 && y2 !== y2;
+    }
+  }
+  function isMap$1(target2) {
+    return target2 instanceof Map;
+  }
+  function isSet$1(target2) {
+    return target2 instanceof Set;
+  }
+  function latest(state) {
+    return state.copy_ || state.base_;
+  }
+  function shallowCopy(base, strict) {
+    if (isMap$1(base)) {
+      return new Map(base);
+    }
+    if (isSet$1(base)) {
+      return new Set(base);
+    }
+    if (Array.isArray(base))
+      return Array.prototype.slice.call(base);
+    const isPlain = isPlainObject$2(base);
+    if (strict === true || strict === "class_only" && !isPlain) {
+      const descriptors = Object.getOwnPropertyDescriptors(base);
+      delete descriptors[DRAFT_STATE];
+      let keys = Reflect.ownKeys(descriptors);
+      for (let i2 = 0; i2 < keys.length; i2++) {
+        const key = keys[i2];
+        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,
+            // could live with !!desc.set as well here...
+            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_,
+      // Whenever the modified draft contains a draft from another scope, we
+      // need to prevent auto-freezing so the unowned draft can be finalized.
+      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];
+    const isReplaced = result !== void 0 && result !== baseDraft;
+    if (isReplaced) {
+      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 path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
+      const res = finalize(rootScope, childValue, path);
+      set$1(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$1(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 isArray3 = Array.isArray(base);
+    const state = {
+      type_: isArray3 ? 1 : 0,
+      // Track which produce call this is associated with.
+      scope_: parent ? parent.scope_ : getCurrentScope(),
+      // True for both shallow and deep changes.
+      modified_: false,
+      // Used during finalization.
+      finalized_: false,
+      // Track which properties have been assigned (true) or deleted (false).
+      assigned_: {},
+      // The parent draft state.
+      parent_: parent,
+      // The base state.
+      base_: base,
+      // The base proxy.
+      draft_: null,
+      // set below
+      // The base copy with any updated values.
+      copy_: null,
+      // Called by the `produce` function.
+      revoke_: null,
+      isManual_: false
+    };
+    let target2 = state;
+    let traps = objectTraps;
+    if (isArray3) {
+      target2 = [state];
+      traps = arrayTraps;
+    }
+    const { revoke, proxy } = Proxy.revocable(target2, 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$1(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$1(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 && // special case: handle new props with value 'undefined'
+      (value !== void 0 || prop in state.copy_) || // special case: NaN
+      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$1(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;
+    },
+    // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+    // the same guarantee in ES5 mode.
+    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$1(draft, prop) {
+    const state = draft[DRAFT_STATE];
+    const source = state ? latest(state) : draft;
+    return source[prop];
+  }
+  function readPropFromProto(state, source, prop) {
+    const desc = getDescriptorFromProto(source, prop);
+    return desc ? `value` in desc ? desc.value : (
+      // This is a very special case, if the prop is a getter defined by the
+      // prototype, we should invoke it with the draft as context!
+      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);
+    }
+    return void 0;
+  }
+  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(config2) {
+      this.autoFreeze_ = true;
+      this.useStrictShallowCopy_ = false;
+      this.useStrictIteration_ = true;
+      this.produce = (base, recipe, patchListener) => {
+        if (typeof base === "function" && typeof recipe !== "function") {
+          const defaultBase = recipe;
+          recipe = base;
+          const self2 = this;
+          return function curriedProduce(base2 = defaultBase, ...args) {
+            return self2.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 p2 = [];
+            const ip = [];
+            getPlugin("Patches").generateReplacementPatches_(base, result, p2, ip);
+            patchListener(p2, 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;
+        const result = this.produce(base, recipe, (p2, ip) => {
+          patches = p2;
+          inversePatches = ip;
+        });
+        return [result, patches, inversePatches];
+      };
+      if (typeof config2?.autoFreeze === "boolean")
+        this.setAutoFreeze(config2.autoFreeze);
+      if (typeof config2?.useStrictShallowCopy === "boolean")
+        this.setUseStrictShallowCopy(config2.useStrictShallowCopy);
+      if (typeof config2?.useStrictIteration === "boolean")
+        this.setUseStrictIteration(config2.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 i2;
+      for (i2 = patches.length - 1; i2 >= 0; i2--) {
+        const patch = patches[i2];
+        if (patch.path.length === 0 && patch.op === "replace") {
+          base = patch.value;
+          break;
+        }
+      }
+      if (i2 > -1) {
+        patches = patches.slice(i2 + 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$1(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet$1(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+    const scope = parent ? parent.scope_ : getCurrentScope();
+    scope.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 copy2;
+    let strict = true;
+    if (state) {
+      if (!state.modified_)
+        return state.base_;
+      state.finalized_ = true;
+      copy2 = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+      strict = state.scope_.immer_.shouldUseStrictIteration();
+    } else {
+      copy2 = shallowCopy(value, true);
+    }
+    each(
+      copy2,
+      (key, childValue) => {
+        set$1(copy2, key, currentImpl(childValue));
+      },
+      strict
+    );
+    if (state) {
+      state.finalized_ = false;
+    }
+    return copy2;
+  }
+  function enableMapSet() {
+    class DraftMap extends Map {
+      constructor(target2, 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_: target2,
+          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, _map2) => {
+          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 iterator2 = this.keys();
+        return {
+          [Symbol.iterator]: () => this.values(),
+          next: () => {
+            const r2 = iterator2.next();
+            if (r2.done)
+              return r2;
+            const value = this.get(r2.value);
+            return {
+              done: false,
+              value
+            };
+          }
+        };
+      }
+      entries() {
+        const iterator2 = this.keys();
+        return {
+          [Symbol.iterator]: () => this.entries(),
+          next: () => {
+            const r2 = iterator2.next();
+            if (r2.done)
+              return r2;
+            const value = this.get(r2.value);
+            return {
+              done: false,
+              value: [r2.value, value]
+            };
+          }
+        };
+      }
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    }
+    function proxyMap_(target2, parent) {
+      return new DraftMap(target2, parent);
+    }
+    function prepareMapCopy(state) {
+      if (!state.copy_) {
+        state.assigned_ = /* @__PURE__ */ new Map();
+        state.copy_ = new Map(state.base_);
+      }
+    }
+    class DraftSet extends Set {
+      constructor(target2, parent) {
+        super();
+        this[DRAFT_STATE] = {
+          type_: 3,
+          parent_: parent,
+          scope_: parent ? parent.scope_ : getCurrentScope(),
+          modified_: false,
+          finalized_: false,
+          copy_: void 0,
+          base_: target2,
+          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)) : (
+          /* istanbul ignore next */
+          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 iterator2 = this.values();
+        let result = iterator2.next();
+        while (!result.done) {
+          cb.call(thisArg, result.value, result.value, this);
+          result = iterator2.next();
+        }
+      }
+    }
+    function proxySet_(target2, parent) {
+      return new DraftSet(target2, 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();
+  immer.produce;
+  function castDraft(value) {
+    return value;
+  }
   const sortCache = (a2, b2) => {
     return (b2.updated ?? 0) - (a2.updated ?? 0);
   };
@@ -68482,7 +69334,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           complete: result.completed,
           value: result.value
         };
-      }), finalize$1(() => {
+      }), finalize$2(() => {
         job.complete();
       })).subscribe(this);
     }
@@ -69260,7 +70112,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         // abort task on signal
         takeUntil(abort$),
         // close the observable sent to the caller
-        finalize$1(() => subject$.complete()),
+        finalize$2(() => subject$.complete()),
         // catch any unhandled exceptions to not stall the queue
         catchError((err) => {
           subject$.error(err);
@@ -69270,7 +70122,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this.#contextQueue.next(task$);
       return subject$.pipe(
         // if caller subscribes, unsubscribe should abort queue entry
-        finalize$1(() => abort$.next(true))
+        finalize$2(() => abort$.next(true))
       );
     }
     /**