@bynder/compact-view 5.2.3 → 5.2.4

package/index21.js

@@ -1,11 +1,558 @@
-import m from "./index23.js";
-import a from "./index24.js";
-import i from "./index25.js";
-function d(t, r) {
-  i(2, arguments);
-  var e = a(t).getTime(), o = m(r);
-  return new Date(e + o);
-}
-export {
-  d as default
+import { g as Se } from "./sdk-DhxX43BH.js";
+import "react/jsx-runtime";
+import H, { createContext as me } from "react";
+var re = { exports: {} }, k = {}, ne = { exports: {} }, V = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var oe;
+function Pe() {
+  if (oe) return V;
+  oe = 1;
+  var e = H;
+  function t(s, c) {
+    return s === c && (s !== 0 || 1 / s === 1 / c) || s !== s && c !== c;
+  }
+  var r = typeof Object.is == "function" ? Object.is : t, n = e.useState, o = e.useEffect, u = e.useLayoutEffect, i = e.useDebugValue;
+  function a(s, c) {
+    var l = c(), b = n({ inst: { value: l, getSnapshot: c } }), f = b[0].inst, P = b[1];
+    return u(
+      function() {
+        f.value = l, f.getSnapshot = c, d(f) && P({ inst: f });
+      },
+      [s, l, c]
+    ), o(
+      function() {
+        return d(f) && P({ inst: f }), s(function() {
+          d(f) && P({ inst: f });
+        });
+      },
+      [s]
+    ), i(l), l;
+  }
+  function d(s) {
+    var c = s.getSnapshot;
+    s = s.value;
+    try {
+      var l = c();
+      return !r(s, l);
+    } catch {
+      return !0;
+    }
+  }
+  function y(s, c) {
+    return c();
+  }
+  var v = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? y : a;
+  return V.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : v, V;
+}
+var ue;
+function ge() {
+  return ue || (ue = 1, ne.exports = Pe()), ne.exports;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ie;
+function we() {
+  if (ie) return k;
+  ie = 1;
+  var e = H, t = ge();
+  function r(y, v) {
+    return y === v && (y !== 0 || 1 / y === 1 / v) || y !== y && v !== v;
+  }
+  var n = typeof Object.is == "function" ? Object.is : r, o = t.useSyncExternalStore, u = e.useRef, i = e.useEffect, a = e.useMemo, d = e.useDebugValue;
+  return k.useSyncExternalStoreWithSelector = function(y, v, s, c, l) {
+    var b = u(null);
+    if (b.current === null) {
+      var f = { hasValue: !1, value: null };
+      b.current = f;
+    } else f = b.current;
+    b = a(
+      function() {
+        function Z(S) {
+          if (!$) {
+            if ($ = !0, F = S, S = c(S), l !== void 0 && f.hasValue) {
+              var E = f.value;
+              if (l(E, S))
+                return x = E;
+            }
+            return x = S;
+          }
+          if (E = x, n(F, S)) return E;
+          var te = c(S);
+          return l !== void 0 && l(E, te) ? (F = S, E) : (F = S, x = te);
+        }
+        var $ = !1, F, x, ee = s === void 0 ? null : s;
+        return [
+          function() {
+            return Z(v());
+          },
+          ee === null ? void 0 : function() {
+            return Z(ee());
+          }
+        ];
+      },
+      [v, s, c, l]
+    );
+    var P = o(y, b[0], b[1]);
+    return i(
+      function() {
+        f.hasValue = !0, f.value = P;
+      },
+      [P]
+    ), d(P), P;
+  }, k;
+}
+var ae;
+function Oe() {
+  return ae || (ae = 1, re.exports = we()), re.exports;
+}
+var Ee = Oe();
+const ze = /* @__PURE__ */ Se(Ee), { useDebugValue: We } = H, { useSyncExternalStoreWithSelector: Ke } = ze;
+var _e = Symbol.for("immer-nothing"), se = Symbol.for("immer-draftable"), p = Symbol.for("immer-state");
+function h(e, ...t) {
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var z = Object.getPrototypeOf;
+function D(e) {
+  return !!e && !!e[p];
+}
+function w(e) {
+  var t;
+  return e ? de(e) || Array.isArray(e) || !!e[se] || !!((t = e.constructor) != null && t[se]) || M(e) || R(e) : !1;
+}
+var De = Object.prototype.constructor.toString();
+function de(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = z(e);
+  if (t === null)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  return r === Object ? !0 : typeof r == "function" && Function.toString.call(r) === De;
+}
+function C(e, t) {
+  L(e) === 0 ? Reflect.ownKeys(e).forEach((r) => {
+    t(r, e[r], e);
+  }) : e.forEach((r, n) => t(n, r, e));
+}
+function L(e) {
+  const t = e[p];
+  return t ? t.type_ : Array.isArray(e) ? 1 : M(e) ? 2 : R(e) ? 3 : 0;
+}
+function G(e, t) {
+  return L(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function ye(e, t, r) {
+  const n = L(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function Ae(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function M(e) {
+  return e instanceof Map;
+}
+function R(e) {
+  return e instanceof Set;
+}
+function g(e) {
+  return e.copy_ || e.base_;
+}
+function Q(e, t) {
+  if (M(e))
+    return new Map(e);
+  if (R(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = de(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[p];
+    let o = Reflect.ownKeys(n);
+    for (let u = 0; u < o.length; u++) {
+      const i = o[u], a = n[i];
+      a.writable === !1 && (a.writable = !0, a.configurable = !0), (a.get || a.set) && (n[i] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: a.enumerable,
+        value: e[i]
+      });
+    }
+    return Object.create(z(e), n);
+  } else {
+    const n = z(e);
+    if (n !== null && r)
+      return { ...e };
+    const o = Object.create(n);
+    return Object.assign(o, e);
+  }
+}
+function J(e, t = !1) {
+  return I(e) || D(e) || !w(e) || (L(e) > 1 && (e.set = e.add = e.clear = e.delete = je), Object.freeze(e), t && Object.entries(e).forEach(([r, n]) => J(n, !0))), e;
+}
+function je() {
+  h(2);
+}
+function I(e) {
+  return Object.isFrozen(e);
+}
+var Fe = {};
+function O(e) {
+  const t = Fe[e];
+  return t || h(0, e), t;
+}
+var A;
+function he() {
+  return A;
+}
+function xe(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 ce(e, t) {
+  t && (O("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function T(e) {
+  X(e), e.drafts_.forEach(Ce), e.drafts_ = null;
+}
+function X(e) {
+  e === A && (A = e.parent_);
+}
+function fe(e) {
+  return A = xe(A, e);
+}
+function Ce(e) {
+  const t = e[p];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function le(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[p].modified_ && (T(t), h(4)), w(e) && (e = U(t, e), t.parent_ || N(t, e)), t.patches_ && O("Patches").generateReplacementPatches_(
+    r[p].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = U(t, r, []), T(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== _e ? e : void 0;
+}
+function U(e, t, r) {
+  if (I(t))
+    return t;
+  const n = t[p];
+  if (!n)
+    return C(
+      t,
+      (o, u) => pe(e, n, t, o, u, r)
+    ), t;
+  if (n.scope_ !== e)
+    return t;
+  if (!n.modified_)
+    return N(e, n.base_, !0), n.base_;
+  if (!n.finalized_) {
+    n.finalized_ = !0, n.scope_.unfinalizedDrafts_--;
+    const o = n.copy_;
+    let u = o, i = !1;
+    n.type_ === 3 && (u = new Set(o), o.clear(), i = !0), C(
+      u,
+      (a, d) => pe(e, n, o, a, d, r, i)
+    ), N(e, o, !1), r && e.patches_ && O("Patches").generatePatches_(
+      n,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return n.copy_;
+}
+function pe(e, t, r, n, o, u, i) {
+  if (D(o)) {
+    const a = u && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !G(t.assigned_, n) ? u.concat(n) : void 0, d = U(e, o, a);
+    if (ye(r, n, d), D(d))
+      e.canAutoFreeze_ = !1;
+    else
+      return;
+  } else i && r.add(o);
+  if (w(o) && !I(o)) {
+    if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1)
+      return;
+    U(e, o), (!t || !t.scope_.parent_) && typeof n != "symbol" && Object.prototype.propertyIsEnumerable.call(r, n) && N(e, o);
+  }
+}
+function N(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && J(t, r);
+}
+function Ue(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : he(),
+    // 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 o = n, u = Y;
+  r && (o = [n], u = j);
+  const { revoke: i, proxy: a } = Proxy.revocable(o, u);
+  return n.draft_ = a, n.revoke_ = i, a;
+}
+var Y = {
+  get(e, t) {
+    if (t === p)
+      return e;
+    const r = g(e);
+    if (!G(r, t))
+      return Ne(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !w(n) ? n : n === W(e.base_, t) ? (K(e), e.copy_[t] = B(n, e)) : n;
+  },
+  has(e, t) {
+    return t in g(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(g(e));
+  },
+  set(e, t, r) {
+    const n = ve(g(e), t);
+    if (n != null && n.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const o = W(g(e), t), u = o?.[p];
+      if (u && u.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (Ae(r, o) && (r !== void 0 || G(e.base_, t)))
+        return !0;
+      K(e), q(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 W(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, K(e), q(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 = g(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    h(11);
+  },
+  getPrototypeOf(e) {
+    return z(e.base_);
+  },
+  setPrototypeOf() {
+    h(12);
+  }
+}, j = {};
+C(Y, (e, t) => {
+  j[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+j.deleteProperty = function(e, t) {
+  return j.set.call(this, e, t, void 0);
 };
+j.set = function(e, t, r) {
+  return Y.set.call(this, e[0], t, r, e[0]);
+};
+function W(e, t) {
+  const r = e[p];
+  return (r ? g(r) : e)[t];
+}
+function Ne(e, t, r) {
+  var n;
+  const o = ve(t, r);
+  return o ? "value" in o ? o.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 = o.get) == null ? void 0 : n.call(e.draft_)
+  ) : void 0;
+}
+function ve(e, t) {
+  if (!(t in e))
+    return;
+  let r = z(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = z(r);
+  }
+}
+function q(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && q(e.parent_));
+}
+function K(e) {
+  e.copy_ || (e.copy_ = Q(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Le = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const u = r;
+        r = t;
+        const i = this;
+        return function(a = u, ...d) {
+          return i.produce(a, (y) => r.call(this, y, ...d));
+        };
+      }
+      typeof r != "function" && h(6), n !== void 0 && typeof n != "function" && h(7);
+      let o;
+      if (w(t)) {
+        const u = fe(this), i = B(t, void 0);
+        let a = !0;
+        try {
+          o = r(i), a = !1;
+        } finally {
+          a ? T(u) : X(u);
+        }
+        return ce(u, n), le(o, u);
+      } else if (!t || typeof t != "object") {
+        if (o = r(t), o === void 0 && (o = t), o === _e && (o = void 0), this.autoFreeze_ && J(o, !0), n) {
+          const u = [], i = [];
+          O("Patches").generateReplacementPatches_(t, o, u, i), n(u, i);
+        }
+        return o;
+      } else
+        h(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (u, ...i) => this.produceWithPatches(u, (a) => t(a, ...i));
+      let n, o;
+      return [this.produce(t, r, (u, i) => {
+        n = u, o = i;
+      }), n, o];
+    }, typeof e?.autoFreeze == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof e?.useStrictShallowCopy == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy);
+  }
+  createDraft(e) {
+    w(e) || h(8), D(e) && (e = Me(e));
+    const t = fe(this), r = B(e, void 0);
+    return r[p].isManual_ = !0, X(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[p];
+    (!r || !r.isManual_) && h(9);
+    const { scope_: n } = r;
+    return ce(n, t), le(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;
+  }
+  applyPatches(e, t) {
+    let r;
+    for (r = t.length - 1; r >= 0; r--) {
+      const o = t[r];
+      if (o.path.length === 0 && o.op === "replace") {
+        e = o.value;
+        break;
+      }
+    }
+    r > -1 && (t = t.slice(r + 1));
+    const n = O("Patches").applyPatches_;
+    return D(e) ? n(e, t) : this.produce(
+      e,
+      (o) => n(o, t)
+    );
+  }
+};
+function B(e, t) {
+  const r = M(e) ? O("MapSet").proxyMap_(e, t) : R(e) ? O("MapSet").proxySet_(e, t) : Ue(e, t);
+  return (t ? t.scope_ : he()).drafts_.push(r), r;
+}
+function Me(e) {
+  return D(e) || h(10, e), be(e);
+}
+function be(e) {
+  if (!w(e) || I(e))
+    return e;
+  const t = e[p];
+  let r;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = Q(e, t.scope_.immer_.useStrictShallowCopy_);
+  } else
+    r = Q(e, !0);
+  return C(r, (n, o) => {
+    ye(r, n, be(o));
+  }), t && (t.finalized_ = !1), r;
+}
+var _ = new Le();
+_.produce;
+_.produceWithPatches.bind(
+  _
+);
+_.setAutoFreeze.bind(_);
+_.setUseStrictShallowCopy.bind(_);
+_.applyPatches.bind(_);
+_.createDraft.bind(_);
+_.finishDraft.bind(_);
+var m = /* @__PURE__ */ ((e) => (e.Idle = "IDLE", e.Pending = "PENDING", e.Queued = "QUEUED", e.Uploading = "UPLOADING", e.Uploaded = "UPLOADED", e.Cancelled = "CANCELLED", e.Failed = "FAILED", e.Paused = "PAUSED", e))(m || {});
+m.Pending, m.Uploading;
+m.Idle, m.Paused;
+m.Paused, m.Uploading, m.Queued, m.Pending;
+const Re = me(null), { Provider: Ge } = Re;

package/index22.js

@@ -1,4 +1,4 @@
-import "./index42.js";
+import "./index43.js";
 import "./RequestHandler.js";
 import "./cookieStore.js";
 import "./decorators.js";

package/index23.js

@@ -1,9 +1,122 @@
-function n(a) {
-  if (a === null || a === !0 || a === !1)
-    return NaN;
-  var e = Number(a);
-  return isNaN(e) ? e : e < 0 ? Math.ceil(e) : Math.floor(e);
+import * as g from "react";
+var S = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new WeakMap(), A = 0, V = void 0;
+function M(e) {
+  return e ? (h.has(e) || (A += 1, h.set(e, A.toString())), h.get(e)) : "0";
+}
+function O(e) {
+  return Object.keys(e).sort().filter(
+    (t) => e[t] !== void 0
+  ).map((t) => `${t}_${t === "root" ? M(e.root) : e[t]}`).toString();
+}
+function T(e) {
+  const t = O(e);
+  let n = S.get(t);
+  if (!n) {
+    const u = /* @__PURE__ */ new Map();
+    let c;
+    const i = new IntersectionObserver((s) => {
+      s.forEach((r) => {
+        var o;
+        const v = r.isIntersecting && c.some((d) => r.intersectionRatio >= d);
+        e.trackVisibility && typeof r.isVisible > "u" && (r.isVisible = v), (o = u.get(r.target)) == null || o.forEach((d) => {
+          d(v, r);
+        });
+      });
+    }, e);
+    c = i.thresholds || (Array.isArray(e.threshold) ? e.threshold : [e.threshold || 0]), n = {
+      id: t,
+      observer: i,
+      elements: u
+    }, S.set(t, n);
+  }
+  return n;
+}
+function x(e, t, n = {}, u = V) {
+  if (typeof window.IntersectionObserver > "u" && u !== void 0) {
+    const o = e.getBoundingClientRect();
+    return t(u, {
+      isIntersecting: u,
+      target: e,
+      intersectionRatio: typeof n.threshold == "number" ? n.threshold : 0,
+      time: 0,
+      boundingClientRect: o,
+      intersectionRect: o,
+      rootBounds: o
+    }), () => {
+    };
+  }
+  const { id: c, observer: i, elements: s } = T(n), r = s.get(e) || [];
+  return s.has(e) || s.set(e, r), r.push(t), i.observe(e), function() {
+    r.splice(r.indexOf(t), 1), r.length === 0 && (s.delete(e), i.unobserve(e)), s.size === 0 && (i.disconnect(), S.delete(c));
+  };
+}
+function B({
+  threshold: e,
+  delay: t,
+  trackVisibility: n,
+  rootMargin: u,
+  root: c,
+  triggerOnce: i,
+  skip: s,
+  initialInView: r,
+  fallbackInView: o,
+  onChange: v
+} = {}) {
+  var d;
+  const [b, E] = g.useState(null), l = g.useRef(v), [R, y] = g.useState({
+    inView: !!r,
+    entry: void 0
+  });
+  l.current = v, g.useEffect(
+    () => {
+      if (s || !b) return;
+      let a;
+      return a = x(
+        b,
+        (p, I) => {
+          y({
+            inView: p,
+            entry: I
+          }), l.current && l.current(p, I), I.isIntersecting && i && a && (a(), a = void 0);
+        },
+        {
+          root: c,
+          rootMargin: u,
+          threshold: e,
+          // @ts-ignore
+          trackVisibility: n,
+          // @ts-ignore
+          delay: t
+        },
+        o
+      ), () => {
+        a && a();
+      };
+    },
+    // We break the rule here, because we aren't including the actual `threshold` variable
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // If the threshold is an array, convert it to a string, so it won't change between renders.
+      Array.isArray(e) ? e.toString() : e,
+      b,
+      c,
+      u,
+      i,
+      s,
+      n,
+      o,
+      t
+    ]
+  );
+  const w = (d = R.entry) == null ? void 0 : d.target, _ = g.useRef(void 0);
+  !b && w && !i && !s && _.current !== w && (_.current = w, y({
+    inView: !!r,
+    entry: void 0
+  }));
+  const f = [E, R.inView, R.entry];
+  return f.ref = f[0], f.inView = f[1], f.entry = f[2], f;
 }
 export {
-  n as default
+  x as observe,
+  B as useInView
 };