@ynput/ayon-frontend-shared 0.3.18 → 0.3.19

package/dist/shared/node_modules/immer/dist/immer.es.js

@@ -0,0 +1,828 @@
+var ye = Symbol.for("immer-nothing"), x = Symbol.for("immer-draftable"), g = Symbol.for("immer-state"), Ce = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+  },
+  function(e) {
+    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 '${e}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+  },
+  "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(e) {
+    return `'current' expects a draft, got: ${e}`;
+  },
+  "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(e) {
+    return `'original' expects a draft, got: ${e}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function m(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = Ce[e], n = F(r) ? r.apply(null, t) : r;
+    throw new Error(`[Immer] ${n}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var v = Object, D = v.getPrototypeOf, L = "constructor", K = "prototype", ue = "configurable", j = "enumerable", Q = "writable", W = "value", z = (e) => !!e && !!e[g];
+function I(e) {
+  return e ? Ee(e) || H(e) || !!e[x] || !!e[L]?.[x] || X(e) || q(e) : !1;
+}
+var Te = v[K][L].toString(), Se = /* @__PURE__ */ new WeakMap();
+function Ee(e) {
+  if (!e || !V(e))
+    return !1;
+  const t = D(e);
+  if (t === null || t === v[K])
+    return !0;
+  const r = v.hasOwnProperty.call(t, L) && t[L];
+  if (r === Object)
+    return !0;
+  if (!F(r))
+    return !1;
+  let n = Se.get(r);
+  return n === void 0 && (n = Function.toString.call(r), Se.set(r, n)), n === Te;
+}
+function Ze(e) {
+  return z(e) || m(15, e), e[g].base_;
+}
+function Y(e, t, r = !0) {
+  M(e) === 0 ? (r ? Reflect.ownKeys(e) : v.keys(e)).forEach((i) => {
+    t(i, e[i], e);
+  }) : e.forEach((n, i) => t(i, n, e));
+}
+function M(e) {
+  const t = e[g];
+  return t ? t.type_ : H(e) ? 1 : X(e) ? 2 : q(e) ? 3 : 0;
+}
+var U = (e, t, r = M(e)) => r === 2 ? e.has(t) : v[K].hasOwnProperty.call(e, t), A = (e, t, r = M(e)) => (
+  // @ts-ignore
+  r === 2 ? e.get(t) : e[t]
+), ee = (e, t, r, n = M(e)) => {
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+};
+function Ve(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+var H = Array.isArray, X = (e) => e instanceof Map, q = (e) => e instanceof Set, V = (e) => typeof e == "object", F = (e) => typeof e == "function", ae = (e) => typeof e == "boolean";
+function xe(e) {
+  const t = +e;
+  return Number.isInteger(t) && String(t) === e;
+}
+var Ue = (e) => V(e) ? e?.[g] : null, C = (e) => e.copy_ || e.base_, me = (e) => e.modified_ ? e.copy_ : e.base_;
+function le(e, t) {
+  if (X(e))
+    return new Map(e);
+  if (q(e))
+    return new Set(e);
+  if (H(e))
+    return Array[K].slice.call(e);
+  const r = Ee(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = v.getOwnPropertyDescriptors(e);
+    delete n[g];
+    let i = Reflect.ownKeys(n);
+    for (let o = 0; o < i.length; o++) {
+      const u = i[o], _ = n[u];
+      _[Q] === !1 && (_[Q] = !0, _[ue] = !0), (_.get || _.set) && (n[u] = {
+        [ue]: !0,
+        [Q]: !0,
+        // could live with !!desc.set as well here...
+        [j]: _[j],
+        [W]: e[u]
+      });
+    }
+    return v.create(D(e), n);
+  } else {
+    const n = D(e);
+    if (n !== null && r)
+      return { ...e };
+    const i = v.create(n);
+    return v.assign(i, e);
+  }
+}
+function ge(e, t = !1) {
+  return ce(e) || z(e) || !I(e) || (M(e) > 1 && v.defineProperties(e, {
+    set: J,
+    add: J,
+    clear: J,
+    delete: J
+  }), v.freeze(e), t && Y(
+    e,
+    (r, n) => {
+      ge(n, !0);
+    },
+    !1
+  )), e;
+}
+function Le() {
+  m(2);
+}
+var J = {
+  [W]: Le
+};
+function ce(e) {
+  return e === null || !V(e) ? !0 : v.isFrozen(e);
+}
+var te = "MapSet", re = "Patches", ve = "ArrayMethods", ne = {};
+function b(e) {
+  const t = ne[e];
+  return t || m(0, e), t;
+}
+var we = (e) => !!ne[e];
+function We(e, t) {
+  ne[e] || (ne[e] = t);
+}
+var $, ke = () => $, $e = (e, t) => ({
+  drafts_: [],
+  parent_: e,
+  immer_: t,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: !0,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: we(te) ? b(te) : void 0,
+  arrayMethodsPlugin_: we(ve) ? b(ve) : void 0
+});
+function Oe(e, t) {
+  t && (e.patchPlugin_ = b(re), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function de(e) {
+  _e(e), e.drafts_.forEach(Be), e.drafts_ = null;
+}
+function _e(e) {
+  e === $ && ($ = e.parent_);
+}
+var ze = (e) => $ = $e($, e);
+function Be(e) {
+  const t = e[g];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function Ie(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  if (e !== void 0 && e !== r) {
+    r[g].modified_ && (de(t), m(4)), I(e) && (e = Ae(t, e));
+    const { patchPlugin_: i } = t;
+    i && i.generateReplacementPatches_(
+      r[g].base_,
+      e,
+      t
+    );
+  } else
+    e = Ae(t, r);
+  return Ge(t, e, !0), de(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== ye ? e : void 0;
+}
+function Ae(e, t) {
+  if (ce(t))
+    return t;
+  const r = t[g];
+  if (!r)
+    return ie(t, e.handledSet_, e);
+  if (!se(r, e))
+    return t;
+  if (!r.modified_)
+    return r.base_;
+  if (!r.finalized_) {
+    const { callbacks_: n } = r;
+    if (n)
+      for (; n.length > 0; )
+        n.pop()(e);
+    Me(r, e);
+  }
+  return r.copy_;
+}
+function Ge(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && ge(t, r);
+}
+function Fe(e) {
+  e.finalized_ = !0, e.scope_.unfinalizedDrafts_--;
+}
+var se = (e, t) => e.scope_ === t, Ke = [];
+function De(e, t, r, n) {
+  const i = C(e), o = e.type_;
+  if (n !== void 0 && A(i, n, o) === t) {
+    ee(i, n, r, o);
+    return;
+  }
+  if (!e.draftLocations_) {
+    const _ = e.draftLocations_ = /* @__PURE__ */ new Map();
+    Y(i, (w, O) => {
+      if (z(O)) {
+        const N = _.get(O) || [];
+        N.push(w), _.set(O, N);
+      }
+    });
+  }
+  const u = e.draftLocations_.get(t) ?? Ke;
+  for (const _ of u)
+    ee(i, _, r, o);
+}
+function Ye(e, t, r) {
+  e.callbacks_.push(function(i) {
+    const o = t;
+    if (!o || !se(o, i))
+      return;
+    i.mapSetPlugin_?.fixSetContents(o);
+    const u = me(o);
+    De(e, o.draft_ ?? o, u, r), Me(o, i);
+  });
+}
+function Me(e, t) {
+  if (e.modified_ && !e.finalized_ && (e.type_ === 3 || e.type_ === 1 && e.allIndicesReassigned_ || (e.assigned_?.size ?? 0) > 0)) {
+    const { patchPlugin_: n } = t;
+    if (n) {
+      const i = n.getPath(e);
+      i && n.generatePatches_(e, i, t);
+    }
+    Fe(e);
+  }
+}
+function He(e, t, r) {
+  const { scope_: n } = e;
+  if (z(r)) {
+    const i = r[g];
+    se(i, n) && i.callbacks_.push(function() {
+      Z(e);
+      const u = me(i);
+      De(e, r, u, t);
+    });
+  } else I(r) && e.callbacks_.push(function() {
+    const o = C(e);
+    e.type_ === 3 ? o.has(r) && ie(r, n.handledSet_, n) : A(o, t, e.type_) === r && n.drafts_.length > 1 && (e.assigned_.get(t) ?? !1) === !0 && e.copy_ && ie(
+      A(e.copy_, t, e.type_),
+      n.handledSet_,
+      n
+    );
+  });
+}
+function ie(e, t, r) {
+  return !r.immer_.autoFreeze_ && r.unfinalizedDrafts_ < 1 || z(e) || t.has(e) || !I(e) || ce(e) || (t.add(e), Y(e, (n, i) => {
+    if (z(i)) {
+      const o = i[g];
+      if (se(o, r)) {
+        const u = me(o);
+        ee(e, n, u, e.type_), Fe(o);
+      }
+    } else I(i) && ie(i, t, r);
+  })), e;
+}
+function Xe(e, t) {
+  const r = H(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : ke(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
+  };
+  let i = n, o = oe;
+  r && (i = [n], o = B);
+  const { revoke: u, proxy: _ } = Proxy.revocable(i, o);
+  return n.draft_ = _, n.revoke_ = u, [_, n];
+}
+var oe = {
+  get(e, t) {
+    if (t === g)
+      return e;
+    let r = e.scope_.arrayMethodsPlugin_;
+    const n = e.type_ === 1 && typeof t == "string";
+    if (n && r?.isArrayOperationMethod(t))
+      return r.createMethodInterceptor(e, t);
+    const i = C(e);
+    if (!U(i, t, e.type_))
+      return qe(e, i, t);
+    const o = i[t];
+    if (e.finalized_ || !I(o) || n && e.operationMethod && r?.isMutatingArrayMethod(
+      e.operationMethod
+    ) && xe(t))
+      return o;
+    if (o === fe(e.base_, t)) {
+      Z(e);
+      const u = e.type_ === 1 ? +t : t, _ = he(e.scope_, o, e, u);
+      return e.copy_[u] = _;
+    }
+    return o;
+  },
+  has(e, t) {
+    return t in C(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(C(e));
+  },
+  set(e, t, r) {
+    const n = be(C(e), t);
+    if (n?.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const i = fe(C(e), t), o = i?.[g];
+      if (o && o.base_ === r)
+        return e.copy_[t] = r, e.assigned_.set(t, !1), !0;
+      if (Ve(r, i) && (r !== void 0 || U(e.base_, t, e.type_)))
+        return !0;
+      Z(e), pe(e);
+    }
+    return e.copy_[t] === r && // special case: handle new props with value 'undefined'
+    (r !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(r) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = r, e.assigned_.set(t, !0), He(e, t, r)), !0;
+  },
+  deleteProperty(e, t) {
+    return Z(e), fe(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_.set(t, !1), pe(e)) : e.assigned_.delete(t), e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const r = C(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      [Q]: !0,
+      [ue]: e.type_ !== 1 || t !== "length",
+      [j]: n[j],
+      [W]: r[t]
+    };
+  },
+  defineProperty() {
+    m(11);
+  },
+  getPrototypeOf(e) {
+    return D(e.base_);
+  },
+  setPrototypeOf() {
+    m(12);
+  }
+}, B = {};
+for (let e in oe) {
+  let t = oe[e];
+  B[e] = function() {
+    const r = arguments;
+    return r[0] = r[0][0], t.apply(this, r);
+  };
+}
+B.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && m(13), B.set.call(this, e, t, void 0);
+};
+B.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && m(14), oe.set.call(this, e[0], t, r, e[0]);
+};
+function fe(e, t) {
+  const r = e[g];
+  return (r ? C(r) : e)[t];
+}
+function qe(e, t, r) {
+  const n = be(t, r);
+  return n ? W in n ? n[W] : (
+    // 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!
+    n.get?.call(e.draft_)
+  ) : void 0;
+}
+function be(e, t) {
+  if (!(t in e))
+    return;
+  let r = D(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = D(r);
+  }
+}
+function pe(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && pe(e.parent_));
+}
+function Z(e) {
+  e.copy_ || (e.assigned_ = /* @__PURE__ */ new Map(), e.copy_ = le(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Je = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, this.produce = (t, r, n) => {
+      if (F(t) && !F(r)) {
+        const o = r;
+        r = t;
+        const u = this;
+        return function(w = o, ...O) {
+          return u.produce(w, (N) => r.call(this, N, ...O));
+        };
+      }
+      F(r) || m(6), n !== void 0 && !F(n) && m(7);
+      let i;
+      if (I(t)) {
+        const o = ze(this), u = he(o, t, void 0);
+        let _ = !0;
+        try {
+          i = r(u), _ = !1;
+        } finally {
+          _ ? de(o) : _e(o);
+        }
+        return Oe(o, n), Ie(i, o);
+      } else if (!t || !V(t)) {
+        if (i = r(t), i === void 0 && (i = t), i === ye && (i = void 0), this.autoFreeze_ && ge(i, !0), n) {
+          const o = [], u = [];
+          b(re).generateReplacementPatches_(t, i, {
+            patches_: o,
+            inversePatches_: u
+          }), n(o, u);
+        }
+        return i;
+      } else
+        m(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (F(t))
+        return (u, ..._) => this.produceWithPatches(u, (w) => t(w, ..._));
+      let n, i;
+      return [this.produce(t, r, (u, _) => {
+        n = u, i = _;
+      }), n, i];
+    }, ae(e?.autoFreeze) && this.setAutoFreeze(e.autoFreeze), ae(e?.useStrictShallowCopy) && this.setUseStrictShallowCopy(e.useStrictShallowCopy), ae(e?.useStrictIteration) && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    I(e) || m(8), z(e) && (e = Qe(e));
+    const t = ze(this), r = he(t, e, void 0);
+    return r[g].isManual_ = !0, _e(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[g];
+    (!r || !r.isManual_) && m(9);
+    const { scope_: n } = r;
+    return Oe(n, t), Ie(void 0, n);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * 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(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  /**
+   * 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(e) {
+    this.useStrictIteration_ = e;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(e, t) {
+    let r;
+    for (r = t.length - 1; r >= 0; r--) {
+      const i = t[r];
+      if (i.path.length === 0 && i.op === "replace") {
+        e = i.value;
+        break;
+      }
+    }
+    r > -1 && (t = t.slice(r + 1));
+    const n = b(re).applyPatches_;
+    return z(e) ? n(e, t) : this.produce(
+      e,
+      (i) => n(i, t)
+    );
+  }
+};
+function he(e, t, r, n) {
+  const [i, o] = X(t) ? b(te).proxyMap_(t, r) : q(t) ? b(te).proxySet_(t, r) : Xe(t, r);
+  return (r?.scope_ ?? ke()).drafts_.push(i), o.callbacks_ = r?.callbacks_ ?? [], o.key_ = n, r && n !== void 0 ? Ye(r, o, n) : o.callbacks_.push(function(w) {
+    w.mapSetPlugin_?.fixSetContents(o);
+    const { patchPlugin_: O } = w;
+    o.modified_ && O && O.generatePatches_(o, [], w);
+  }), i;
+}
+function Qe(e) {
+  return z(e) || m(10, e), Ne(e);
+}
+function Ne(e) {
+  if (!I(e) || ce(e))
+    return e;
+  const t = e[g];
+  let r, n = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = le(e, t.scope_.immer_.useStrictShallowCopy_), n = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    r = le(e, !0);
+  return Y(
+    r,
+    (i, o) => {
+      ee(r, i, Ne(o));
+    },
+    n
+  ), t && (t.finalized_ = !1), r;
+}
+function je() {
+  process.env.NODE_ENV !== "production" && Ce.push(
+    'Sets cannot have "replace" patches.',
+    function(c) {
+      return "Unsupported patch operation: " + c;
+    },
+    function(c) {
+      return "Cannot apply patch, path doesn't resolve: " + c;
+    },
+    "Patching reserved attributes like __proto__, prototype and constructor is not allowed"
+  );
+  function t(c, f = []) {
+    if (c.key_ !== void 0) {
+      const s = c.parent_.copy_ ?? c.parent_.base_, l = Ue(A(s, c.key_)), d = A(s, c.key_);
+      if (d === void 0 || d !== c.draft_ && d !== c.base_ && d !== c.copy_ || l != null && l.base_ !== c.base_)
+        return null;
+      const p = c.parent_.type_ === 3;
+      let h;
+      if (p) {
+        const y = c.parent_;
+        h = Array.from(y.drafts_.keys()).indexOf(c.key_);
+      } else
+        h = c.key_;
+      if (!(p && s.size > h || U(s, h)))
+        return null;
+      f.push(h);
+    }
+    if (c.parent_)
+      return t(c.parent_, f);
+    f.reverse();
+    try {
+      r(c.copy_, f);
+    } catch {
+      return null;
+    }
+    return f;
+  }
+  function r(c, f) {
+    let s = c;
+    for (let l = 0; l < f.length - 1; l++) {
+      const d = f[l];
+      if (s = A(s, d), !V(s) || s === null)
+        throw new Error(`Cannot resolve path at '${f.join("/")}'`);
+    }
+    return s;
+  }
+  const n = "replace", i = "add", o = "remove";
+  function u(c, f, s) {
+    if (c.scope_.processedForPatches_.has(c))
+      return;
+    c.scope_.processedForPatches_.add(c);
+    const { patches_: l, inversePatches_: d } = s;
+    switch (c.type_) {
+      case 0:
+      case 2:
+        return w(
+          c,
+          f,
+          l,
+          d
+        );
+      case 1:
+        return _(
+          c,
+          f,
+          l,
+          d
+        );
+      case 3:
+        return O(
+          c,
+          f,
+          l,
+          d
+        );
+    }
+  }
+  function _(c, f, s, l) {
+    let { base_: d, assigned_: p } = c, h = c.copy_;
+    h.length < d.length && ([d, h] = [h, d], [s, l] = [l, s]);
+    const y = c.allIndicesReassigned_ === !0;
+    for (let a = 0; a < d.length; a++) {
+      const S = h[a], E = d[a];
+      if ((y || p?.get(a.toString())) && S !== E) {
+        const k = S?.[g];
+        if (k && k.modified_)
+          continue;
+        const Pe = f.concat([a]);
+        s.push({
+          op: n,
+          path: Pe,
+          // Need to maybe clone it, as it can in fact be the original value
+          // due to the base/copy inversion at the start of this function
+          value: T(S)
+        }), l.push({
+          op: n,
+          path: Pe,
+          value: T(E)
+        });
+      }
+    }
+    for (let a = d.length; a < h.length; a++) {
+      const S = f.concat([a]);
+      s.push({
+        op: i,
+        path: S,
+        // Need to maybe clone it, as it can in fact be the original value
+        // due to the base/copy inversion at the start of this function
+        value: T(h[a])
+      });
+    }
+    for (let a = h.length - 1; d.length <= a; --a) {
+      const S = f.concat([a]);
+      l.push({
+        op: o,
+        path: S
+      });
+    }
+  }
+  function w(c, f, s, l) {
+    const { base_: d, copy_: p, type_: h } = c;
+    Y(c.assigned_, (y, a) => {
+      const S = A(d, y, h), E = A(p, y, h), P = a ? U(d, y) ? n : i : o;
+      if (S === E && P === n)
+        return;
+      const k = f.concat(y);
+      s.push(
+        P === o ? { op: P, path: k } : { op: P, path: k, value: T(E) }
+      ), l.push(
+        P === i ? { op: o, path: k } : P === o ? { op: i, path: k, value: T(S) } : { op: n, path: k, value: T(S) }
+      );
+    });
+  }
+  function O(c, f, s, l) {
+    let { base_: d, copy_: p } = c, h = 0;
+    d.forEach((y) => {
+      if (!p.has(y)) {
+        const a = f.concat([h]);
+        s.push({
+          op: o,
+          path: a,
+          value: y
+        }), l.unshift({
+          op: i,
+          path: a,
+          value: y
+        });
+      }
+      h++;
+    }), h = 0, p.forEach((y) => {
+      if (!d.has(y)) {
+        const a = f.concat([h]);
+        s.push({
+          op: i,
+          path: a,
+          value: y
+        }), l.unshift({
+          op: o,
+          path: a,
+          value: y
+        });
+      }
+      h++;
+    });
+  }
+  function N(c, f, s) {
+    const { patches_: l, inversePatches_: d } = s;
+    l.push({
+      op: n,
+      path: [],
+      value: f === ye ? void 0 : f
+    }), d.push({
+      op: n,
+      path: [],
+      value: c
+    });
+  }
+  function Re(c, f) {
+    return f.forEach((s) => {
+      const { path: l, op: d } = s;
+      let p = c;
+      for (let S = 0; S < l.length - 1; S++) {
+        const E = M(p);
+        let P = l[S];
+        typeof P != "string" && typeof P != "number" && (P = "" + P), (E === 0 || E === 1) && (P === "__proto__" || P === L) && m(19), F(p) && P === K && m(19), p = A(p, P), V(p) || m(18, l.join("/"));
+      }
+      const h = M(p), y = R(s.value), a = l[l.length - 1];
+      switch (d) {
+        case n:
+          switch (h) {
+            case 2:
+              return p.set(a, y);
+            case 3:
+              m(16);
+            default:
+              return p[a] = y;
+          }
+        case i:
+          switch (h) {
+            case 1:
+              return a === "-" ? p.push(y) : p.splice(a, 0, y);
+            case 2:
+              return p.set(a, y);
+            case 3:
+              return p.add(y);
+            default:
+              return p[a] = y;
+          }
+        case o:
+          switch (h) {
+            case 1:
+              return p.splice(a, 1);
+            case 2:
+              return p.delete(a);
+            case 3:
+              return p.delete(s.value);
+            default:
+              return delete p[a];
+          }
+        default:
+          m(17, d);
+      }
+    }), c;
+  }
+  function R(c) {
+    if (!I(c))
+      return c;
+    if (H(c))
+      return c.map(R);
+    if (X(c))
+      return new Map(
+        Array.from(c.entries()).map(([s, l]) => [s, R(l)])
+      );
+    if (q(c))
+      return new Set(Array.from(c).map(R));
+    const f = Object.create(D(c));
+    for (const s in c)
+      f[s] = R(c[s]);
+    return U(c, x) && (f[x] = c[x]), f;
+  }
+  function T(c) {
+    return z(c) ? R(c) : c;
+  }
+  We(re, {
+    applyPatches_: Re,
+    generatePatches_: u,
+    generateReplacementPatches_: N,
+    getPath: t
+  });
+}
+var G = new Je();
+G.produce;
+var et = /* @__PURE__ */ G.produceWithPatches.bind(
+  G
+), tt = /* @__PURE__ */ G.applyPatches.bind(G);
+export {
+  Je as Immer,
+  tt as applyPatches,
+  Qe as current,
+  je as enablePatches,
+  ge as freeze,
+  x as immerable,
+  z as isDraft,
+  I as isDraftable,
+  ye as nothing,
+  Ze as original,
+  et as produceWithPatches
+};
+//# sourceMappingURL=immer.es.js.map