@bynder/compact-view 5.2.0 → 5.2.2

package/immer.js

@@ -0,0 +1,472 @@
+var G = Symbol.for("immer-nothing"), U = Symbol.for("immer-draftable"), s = Symbol.for("immer-state");
+function u(e, ...t) {
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var m = Object.getPrototypeOf;
+function h(e) {
+  return !!e && !!e[s];
+}
+function _(e) {
+  return e ? H(e) || Array.isArray(e) || !!e[U] || !!e.constructor?.[U] || w(e) || A(e) : !1;
+}
+var Y = Object.prototype.constructor.toString(), j = /* @__PURE__ */ new WeakMap();
+function H(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  if (t === null || t === Object.prototype)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  if (r === Object)
+    return !0;
+  if (typeof r != "function")
+    return !1;
+  let n = j.get(r);
+  return n === void 0 && (n = Function.toString.call(r), j.set(r, n)), n === Y;
+}
+function g(e, t, r = !0) {
+  F(e) === 0 ? (r ? Reflect.ownKeys(e) : Object.keys(e)).forEach((i) => {
+    t(i, e[i], e);
+  }) : e.forEach((n, i) => t(i, n, e));
+}
+function F(e) {
+  const t = e[s];
+  return t ? t.type_ : Array.isArray(e) ? 1 : w(e) ? 2 : A(e) ? 3 : 0;
+}
+function D(e, t) {
+  return F(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function X(e, t, r) {
+  const n = F(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function Z(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function w(e) {
+  return e instanceof Map;
+}
+function A(e) {
+  return e instanceof Set;
+}
+function l(e) {
+  return e.copy_ || e.base_;
+}
+function C(e, t) {
+  if (w(e))
+    return new Map(e);
+  if (A(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = H(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[s];
+    let i = Reflect.ownKeys(n);
+    for (let o = 0; o < i.length; o++) {
+      const f = i[o], c = n[f];
+      c.writable === !1 && (c.writable = !0, c.configurable = !0), (c.get || c.set) && (n[f] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: c.enumerable,
+        value: e[f]
+      });
+    }
+    return Object.create(m(e), n);
+  } else {
+    const n = m(e);
+    if (n !== null && r)
+      return { ...e };
+    const i = Object.create(n);
+    return Object.assign(i, e);
+  }
+}
+function N(e, t = !1) {
+  return b(e) || h(e) || !_(e) || (F(e) > 1 && Object.defineProperties(e, {
+    set: z,
+    add: z,
+    clear: z,
+    delete: z
+  }), Object.freeze(e), t && Object.values(e).forEach((r) => N(r, !0))), e;
+}
+function L() {
+  u(2);
+}
+var z = {
+  value: L
+};
+function b(e) {
+  return e === null || typeof e != "object" ? !0 : Object.isFrozen(e);
+}
+var V = {};
+function y(e) {
+  const t = V[e];
+  return t || u(0, e), t;
+}
+var p;
+function $() {
+  return p;
+}
+function ee(e, t) {
+  return {
+    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
+  };
+}
+function x(e, t) {
+  t && (y("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function k(e) {
+  M(e), e.drafts_.forEach(te), e.drafts_ = null;
+}
+function M(e) {
+  e === p && (p = e.parent_);
+}
+function K(e) {
+  return p = ee(p, e);
+}
+function te(e) {
+  const t = e[s];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function W(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[s].modified_ && (k(t), u(4)), _(e) && (e = S(t, e), t.parent_ || O(t, e)), t.patches_ && y("Patches").generateReplacementPatches_(
+    r[s].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = S(t, r, []), k(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== G ? e : void 0;
+}
+function S(e, t, r) {
+  if (b(t))
+    return t;
+  const n = e.immer_.shouldUseStrictIteration(), i = t[s];
+  if (!i)
+    return g(
+      t,
+      (o, f) => B(e, i, t, o, f, r),
+      n
+    ), t;
+  if (i.scope_ !== e)
+    return t;
+  if (!i.modified_)
+    return O(e, i.base_, !0), i.base_;
+  if (!i.finalized_) {
+    i.finalized_ = !0, i.scope_.unfinalizedDrafts_--;
+    const o = i.copy_;
+    let f = o, c = !1;
+    i.type_ === 3 && (f = new Set(o), o.clear(), c = !0), g(
+      f,
+      (a, d) => B(
+        e,
+        i,
+        o,
+        a,
+        d,
+        r,
+        c
+      ),
+      n
+    ), O(e, o, !1), r && e.patches_ && y("Patches").generatePatches_(
+      i,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return i.copy_;
+}
+function B(e, t, r, n, i, o, f) {
+  if (i == null || typeof i != "object" && !f)
+    return;
+  const c = b(i);
+  if (!(c && !f)) {
+    if (h(i)) {
+      const a = o && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !D(t.assigned_, n) ? o.concat(n) : void 0, d = S(e, i, a);
+      if (X(r, n, d), h(d))
+        e.canAutoFreeze_ = !1;
+      else
+        return;
+    } else f && r.add(i);
+    if (_(i) && !c) {
+      if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1 || t && t.base_ && t.base_[n] === i && c)
+        return;
+      S(e, i), (!t || !t.scope_.parent_) && typeof n != "symbol" && (w(r) ? r.has(n) : Object.prototype.propertyIsEnumerable.call(r, n)) && O(e, i);
+    }
+  }
+}
+function O(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && N(t, r);
+}
+function re(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : $(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // 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
+  };
+  let i = n, o = T;
+  r && (i = [n], o = P);
+  const { revoke: f, proxy: c } = Proxy.revocable(i, o);
+  return n.draft_ = c, n.revoke_ = f, c;
+}
+var T = {
+  get(e, t) {
+    if (t === s)
+      return e;
+    const r = l(e);
+    if (!D(r, t))
+      return ne(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !_(n) ? n : n === v(e.base_, t) ? (I(e), e.copy_[t] = R(n, e)) : n;
+  },
+  has(e, t) {
+    return t in l(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(l(e));
+  },
+  set(e, t, r) {
+    const n = q(l(e), t);
+    if (n?.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const i = v(l(e), t), o = i?.[s];
+      if (o && o.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (Z(r, i) && (r !== void 0 || D(e.base_, t)))
+        return !0;
+      I(e), E(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_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return v(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, I(e), E(e)) : delete e.assigned_[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 = l(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    u(11);
+  },
+  getPrototypeOf(e) {
+    return m(e.base_);
+  },
+  setPrototypeOf() {
+    u(12);
+  }
+}, P = {};
+g(T, (e, t) => {
+  P[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+P.deleteProperty = function(e, t) {
+  return P.set.call(this, e, t, void 0);
+};
+P.set = function(e, t, r) {
+  return T.set.call(this, e[0], t, r, e[0]);
+};
+function v(e, t) {
+  const r = e[s];
+  return (r ? l(r) : e)[t];
+}
+function ne(e, t, r) {
+  const n = q(t, r);
+  return n ? "value" in n ? n.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!
+    n.get?.call(e.draft_)
+  ) : void 0;
+}
+function q(e, t) {
+  if (!(t in e))
+    return;
+  let r = m(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = m(r);
+  }
+}
+function E(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && E(e.parent_));
+}
+function I(e) {
+  e.copy_ || (e.copy_ = C(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var ie = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !0, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const o = r;
+        r = t;
+        const f = this;
+        return function(a = o, ...d) {
+          return f.produce(a, (Q) => r.call(this, Q, ...d));
+        };
+      }
+      typeof r != "function" && u(6), n !== void 0 && typeof n != "function" && u(7);
+      let i;
+      if (_(t)) {
+        const o = K(this), f = R(t, void 0);
+        let c = !0;
+        try {
+          i = r(f), c = !1;
+        } finally {
+          c ? k(o) : M(o);
+        }
+        return x(o, n), W(i, o);
+      } else if (!t || typeof t != "object") {
+        if (i = r(t), i === void 0 && (i = t), i === G && (i = void 0), this.autoFreeze_ && N(i, !0), n) {
+          const o = [], f = [];
+          y("Patches").generateReplacementPatches_(t, i, o, f), n(o, f);
+        }
+        return i;
+      } else
+        u(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (f, ...c) => this.produceWithPatches(f, (a) => t(a, ...c));
+      let n, i;
+      return [this.produce(t, r, (f, c) => {
+        n = f, i = c;
+      }), n, i];
+    }, typeof e?.autoFreeze == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof e?.useStrictShallowCopy == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy), typeof e?.useStrictIteration == "boolean" && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    _(e) || u(8), h(e) && (e = oe(e));
+    const t = K(this), r = R(e, void 0);
+    return r[s].isManual_ = !0, M(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[s];
+    (!r || !r.isManual_) && u(9);
+    const { scope_: n } = r;
+    return x(n, t), W(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 = y("Patches").applyPatches_;
+    return h(e) ? n(e, t) : this.produce(
+      e,
+      (i) => n(i, t)
+    );
+  }
+};
+function R(e, t) {
+  const r = w(e) ? y("MapSet").proxyMap_(e, t) : A(e) ? y("MapSet").proxySet_(e, t) : re(e, t);
+  return (t ? t.scope_ : $()).drafts_.push(r), r;
+}
+function oe(e) {
+  return h(e) || u(10, e), J(e);
+}
+function J(e) {
+  if (!_(e) || b(e))
+    return e;
+  const t = e[s];
+  let r, n = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = C(e, t.scope_.immer_.useStrictShallowCopy_), n = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    r = C(e, !0);
+  return g(
+    r,
+    (i, o) => {
+      X(r, i, J(o));
+    },
+    n
+  ), t && (t.finalized_ = !1), r;
+}
+var fe = new ie(), ce = fe.produce;
+export {
+  ie as Immer,
+  oe as current,
+  N as freeze,
+  U as immerable,
+  h as isDraft,
+  _ as isDraftable,
+  G as nothing,
+  ce as produce
+};

package/import.js

@@ -0,0 +1,7 @@
+let e = !1;
+function f() {
+  return e;
+}
+export {
+  f as shadowDOM
+};