@pibit.ai/cure-design-system 0.6.42 → 0.6.43

package/dist/node_modules/immer/dist/immer.js

@@ -0,0 +1,575 @@
+var fe = Symbol.for("immer-nothing"), te = Symbol.for("immer-draftable"), a = Symbol.for("immer-state"), Pe = 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 f(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = Pe[e], n = m(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 u = Object, S = u.getPrototypeOf, O = "constructor", N = "prototype", G = "configurable", D = "enumerable", C = "writable", g = "value", y = (e) => !!e && !!e[a];
+function l(e) {
+  var t;
+  return e ? ue(e) || T(e) || !!e[te] || !!((t = e[O]) != null && t[te]) || x(e) || I(e) : !1;
+}
+var Se = u[N][O].toString(), re = /* @__PURE__ */ new WeakMap();
+function ue(e) {
+  if (!e || !Q(e))
+    return !1;
+  const t = S(e);
+  if (t === null || t === u[N])
+    return !0;
+  const r = u.hasOwnProperty.call(t, O) && t[O];
+  if (r === Object)
+    return !0;
+  if (!m(r))
+    return !1;
+  let n = re.get(r);
+  return n === void 0 && (n = Function.toString.call(r), re.set(r, n)), n === Se;
+}
+function R(e, t, r = !0) {
+  z(e) === 0 ? (r ? Reflect.ownKeys(e) : u.keys(e)).forEach((i) => {
+    t(i, e[i], e);
+  }) : e.forEach((n, i) => t(i, n, e));
+}
+function z(e) {
+  const t = e[a];
+  return t ? t.type_ : T(e) ? 1 : x(e) ? 2 : I(e) ? 3 : 0;
+}
+var L = (e, t, r = z(e)) => r === 2 ? e.has(t) : u[N].hasOwnProperty.call(e, t), K = (e, t, r = z(e)) => (
+  // @ts-ignore
+  r === 2 ? e.get(t) : e[t]
+), k = (e, t, r, n = z(e)) => {
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+};
+function ge(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+var T = Array.isArray, x = (e) => e instanceof Map, I = (e) => e instanceof Set, Q = (e) => typeof e == "object", m = (e) => typeof e == "function", B = (e) => typeof e == "boolean";
+function ve(e) {
+  const t = +e;
+  return Number.isInteger(t) && String(t) === e;
+}
+var _ = (e) => e.copy_ || e.base_, Z = (e) => e.modified_ ? e.copy_ : e.base_;
+function Y(e, t) {
+  if (x(e))
+    return new Map(e);
+  if (I(e))
+    return new Set(e);
+  if (T(e))
+    return Array[N].slice.call(e);
+  const r = ue(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = u.getOwnPropertyDescriptors(e);
+    delete n[a];
+    let i = Reflect.ownKeys(n);
+    for (let o = 0; o < i.length; o++) {
+      const s = i[o], c = n[s];
+      c[C] === !1 && (c[C] = !0, c[G] = !0), (c.get || c.set) && (n[s] = {
+        [G]: !0,
+        [C]: !0,
+        // could live with !!desc.set as well here...
+        [D]: c[D],
+        [g]: e[s]
+      });
+    }
+    return u.create(S(e), n);
+  } else {
+    const n = S(e);
+    if (n !== null && r)
+      return { ...e };
+    const i = u.create(n);
+    return u.assign(i, e);
+  }
+}
+function ee(e, t = !1) {
+  return U(e) || y(e) || !l(e) || (z(e) > 1 && u.defineProperties(e, {
+    set: b,
+    add: b,
+    clear: b,
+    delete: b
+  }), u.freeze(e), t && R(
+    e,
+    (r, n) => {
+      ee(n, !0);
+    },
+    !1
+  )), e;
+}
+function we() {
+  f(2);
+}
+var b = {
+  [g]: we
+};
+function U(e) {
+  return e === null || !Q(e) ? !0 : u.isFrozen(e);
+}
+var M = "MapSet", H = "Patches", ne = "ArrayMethods", le = {};
+function P(e) {
+  const t = le[e];
+  return t || f(0, e), t;
+}
+var ie = (e) => !!le[e], v, de = () => v, ze = (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_: ie(M) ? P(M) : void 0,
+  arrayMethodsPlugin_: ie(ne) ? P(ne) : void 0
+});
+function oe(e, t) {
+  t && (e.patchPlugin_ = P(H), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function X(e) {
+  j(e), e.drafts_.forEach(Ie), e.drafts_ = null;
+}
+function j(e) {
+  e === v && (v = e.parent_);
+}
+var se = (e) => v = ze(v, e);
+function Ie(e) {
+  const t = e[a];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function ce(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  if (e !== void 0 && e !== r) {
+    r[a].modified_ && (X(t), f(4)), l(e) && (e = ae(t, e));
+    const { patchPlugin_: i } = t;
+    i && i.generateReplacementPatches_(
+      r[a].base_,
+      e,
+      t
+    );
+  } else
+    e = ae(t, r);
+  return be(t, e, !0), X(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== fe ? e : void 0;
+}
+function ae(e, t) {
+  if (U(t))
+    return t;
+  const r = t[a];
+  if (!r)
+    return A(t, e.handledSet_, e);
+  if (!V(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);
+    ye(r, e);
+  }
+  return r.copy_;
+}
+function be(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && ee(t, r);
+}
+function _e(e) {
+  e.finalized_ = !0, e.scope_.unfinalizedDrafts_--;
+}
+var V = (e, t) => e.scope_ === t, Ce = [];
+function he(e, t, r, n) {
+  const i = _(e), o = e.type_;
+  if (n !== void 0 && K(i, n, o) === t) {
+    k(i, n, r, o);
+    return;
+  }
+  if (!e.draftLocations_) {
+    const c = e.draftLocations_ = /* @__PURE__ */ new Map();
+    R(i, (d, h) => {
+      if (y(h)) {
+        const p = c.get(h) || [];
+        p.push(d), c.set(h, p);
+      }
+    });
+  }
+  const s = e.draftLocations_.get(t) ?? Ce;
+  for (const c of s)
+    k(i, c, r, o);
+}
+function Fe(e, t, r) {
+  e.callbacks_.push(function(i) {
+    var c;
+    const o = t;
+    if (!o || !V(o, i))
+      return;
+    (c = i.mapSetPlugin_) == null || c.fixSetContents(o);
+    const s = Z(o);
+    he(e, o.draft_ ?? o, s, r), ye(o, i);
+  });
+}
+function ye(e, t) {
+  var n;
+  if (e.modified_ && !e.finalized_ && (e.type_ === 3 || e.type_ === 1 && e.allIndicesReassigned_ || (((n = e.assigned_) == null ? void 0 : n.size) ?? 0) > 0)) {
+    const { patchPlugin_: i } = t;
+    if (i) {
+      const o = i.getPath(e);
+      o && i.generatePatches_(e, o, t);
+    }
+    _e(e);
+  }
+}
+function Oe(e, t, r) {
+  const { scope_: n } = e;
+  if (y(r)) {
+    const i = r[a];
+    V(i, n) && i.callbacks_.push(function() {
+      F(e);
+      const s = Z(i);
+      he(e, r, s, t);
+    });
+  } else l(r) && e.callbacks_.push(function() {
+    const o = _(e);
+    e.type_ === 3 ? o.has(r) && A(r, n.handledSet_, n) : K(o, t, e.type_) === r && n.drafts_.length > 1 && (e.assigned_.get(t) ?? !1) === !0 && e.copy_ && A(
+      K(e.copy_, t, e.type_),
+      n.handledSet_,
+      n
+    );
+  });
+}
+function A(e, t, r) {
+  return !r.immer_.autoFreeze_ && r.unfinalizedDrafts_ < 1 || y(e) || t.has(e) || !l(e) || U(e) || (t.add(e), R(e, (n, i) => {
+    if (y(i)) {
+      const o = i[a];
+      if (V(o, r)) {
+        const s = Z(o);
+        k(e, n, s, e.type_), _e(o);
+      }
+    } else l(i) && A(i, t, r);
+  })), e;
+}
+function De(e, t) {
+  const r = T(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : de(),
+    // 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 = E;
+  r && (i = [n], o = w);
+  const { revoke: s, proxy: c } = Proxy.revocable(i, o);
+  return n.draft_ = c, n.revoke_ = s, [c, n];
+}
+var E = {
+  get(e, t) {
+    if (t === a)
+      return e;
+    let r = e.scope_.arrayMethodsPlugin_;
+    const n = e.type_ === 1 && typeof t == "string";
+    if (n && r != null && r.isArrayOperationMethod(t))
+      return r.createMethodInterceptor(e, t);
+    const i = _(e);
+    if (!L(i, t, e.type_))
+      return Me(e, i, t);
+    const o = i[t];
+    if (e.finalized_ || !l(o) || n && e.operationMethod && (r != null && r.isMutatingArrayMethod(
+      e.operationMethod
+    )) && ve(t))
+      return o;
+    if (o === $(e.base_, t) || ke(e, t, o)) {
+      F(e);
+      const s = e.type_ === 1 ? +t : t, c = J(e.scope_, o, e, s);
+      return e.copy_[s] = c;
+    }
+    return o;
+  },
+  has(e, t) {
+    return t in _(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(_(e));
+  },
+  set(e, t, r) {
+    const n = pe(_(e), t);
+    if (n != null && n.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const i = $(_(e), t), o = i == null ? void 0 : i[a];
+      if (o && o.base_ === r)
+        return e.copy_[t] = r, e.assigned_.delete(t), !0;
+      if (ge(r, i) && (r !== void 0 || L(e.base_, t, e.type_)))
+        return !0;
+      F(e), q(e);
+    }
+    return e.copy_[t] === r && // special case: handle new props with value 'undefined'
+    (r !== void 0 || L(e.copy_, t, e.type_)) || // special case: NaN
+    Number.isNaN(r) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = r, e.assigned_.set(t, !0), Oe(e, t, r)), !0;
+  },
+  deleteProperty(e, t) {
+    return F(e), $(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_.set(t, !1), q(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 = _(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      [C]: !0,
+      [G]: e.type_ !== 1 || t !== "length",
+      [D]: n[D],
+      [g]: r[t]
+    };
+  },
+  defineProperty() {
+    f(11);
+  },
+  getPrototypeOf(e) {
+    return S(e.base_);
+  },
+  setPrototypeOf() {
+    f(12);
+  }
+}, w = {};
+for (let e in E) {
+  let t = E[e];
+  w[e] = function() {
+    const r = arguments;
+    return r[0] = r[0][0], t.apply(this, r);
+  };
+}
+w.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && f(13), w.set.call(this, e, t, void 0);
+};
+w.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && f(14), E.set.call(this, e[0], t, r, e[0]);
+};
+function $(e, t) {
+  const r = e[a];
+  return (r ? _(r) : e)[t];
+}
+function ke(e, t, r) {
+  return e.type_ !== 1 || !e.allIndicesReassigned_ || !l(r) || r[a] ? !1 : e.baseRefs_.has(r);
+}
+function Me(e, t, r) {
+  var i;
+  const n = pe(t, r);
+  return n ? g in n ? n[g] : (
+    // 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!
+    (i = n.get) == null ? void 0 : i.call(e.draft_)
+  ) : void 0;
+}
+function pe(e, t) {
+  if (!(t in e))
+    return;
+  let r = S(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = S(r);
+  }
+}
+function q(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && q(e.parent_));
+}
+function F(e) {
+  e.copy_ || (e.assigned_ = /* @__PURE__ */ new Map(), e.copy_ = Y(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Ae = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, this.produce = (t, r, n) => {
+      if (m(t) && !m(r)) {
+        const o = r;
+        r = t;
+        const s = this;
+        return function(d = o, ...h) {
+          return s.produce(d, (p) => r.call(this, p, ...h));
+        };
+      }
+      m(r) || f(6), n !== void 0 && !m(n) && f(7);
+      let i;
+      if (l(t)) {
+        const o = se(this), s = J(o, t, void 0);
+        let c = !0;
+        try {
+          i = r(s), c = !1;
+        } finally {
+          c ? X(o) : j(o);
+        }
+        return oe(o, n), ce(i, o);
+      } else if (!t || !Q(t)) {
+        if (i = r(t), i === void 0 && (i = t), i === fe && (i = void 0), this.autoFreeze_ && ee(i, !0), n) {
+          const o = [], s = [];
+          P(H).generateReplacementPatches_(t, i, {
+            patches_: o,
+            inversePatches_: s
+          }), n(o, s);
+        }
+        return i;
+      } else
+        f(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (m(t))
+        return (s, ...c) => this.produceWithPatches(s, (d) => t(d, ...c));
+      let n, i;
+      return [this.produce(t, r, (s, c) => {
+        n = s, i = c;
+      }), n, i];
+    }, B(e == null ? void 0 : e.autoFreeze) && this.setAutoFreeze(e.autoFreeze), B(e == null ? void 0 : e.useStrictShallowCopy) && this.setUseStrictShallowCopy(e.useStrictShallowCopy), B(e == null ? void 0 : e.useStrictIteration) && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    l(e) || f(8), y(e) && (e = Ee(e));
+    const t = se(this), r = J(t, e, void 0);
+    return r[a].isManual_ = !0, j(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[a];
+    (!r || !r.isManual_) && f(9);
+    const { scope_: n } = r;
+    return oe(n, t), ce(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 = P(H).applyPatches_;
+    return y(e) ? n(e, t) : this.produce(
+      e,
+      (i) => n(i, t)
+    );
+  }
+};
+function J(e, t, r, n) {
+  const [i, o] = x(t) ? P(M).proxyMap_(t, r) : I(t) ? P(M).proxySet_(t, r) : De(t, r);
+  return ((r == null ? void 0 : r.scope_) ?? de()).drafts_.push(i), o.callbacks_ = (r == null ? void 0 : r.callbacks_) ?? [], o.key_ = n, r && n !== void 0 ? Fe(r, o, n) : o.callbacks_.push(function(d) {
+    var p;
+    (p = d.mapSetPlugin_) == null || p.fixSetContents(o);
+    const { patchPlugin_: h } = d;
+    o.modified_ && h && h.generatePatches_(o, [], d);
+  }), i;
+}
+function Ee(e) {
+  return y(e) || f(10, e), me(e);
+}
+function me(e) {
+  if (!l(e) || U(e))
+    return e;
+  const t = e[a];
+  let r, n = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = Y(e, t.scope_.immer_.useStrictShallowCopy_), n = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    r = Y(e, !0);
+  const i = r;
+  return I(r) && (r = /* @__PURE__ */ new Set()), R(
+    i,
+    (o, s) => {
+      k(r, o, me(s));
+    },
+    n
+  ), t && (t.finalized_ = !1), r;
+}
+var W = globalThis.Iterator;
+W == null || W.from;
+var Ne = new Ae(), Re = Ne.produce, Te = (e) => e;
+export {
+  Ae as Immer,
+  Te as castDraft,
+  Ee as current,
+  ee as freeze,
+  te as immerable,
+  y as isDraft,
+  l as isDraftable,
+  fe as nothing,
+  Re as produce
+};

package/dist/node_modules/internmap/src/index.js

@@ -0,0 +1,35 @@
+class i extends Map {
+  constructor(t, s = f) {
+    if (super(), Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: s } }), t != null) for (const [r, o] of t) this.set(r, o);
+  }
+  get(t) {
+    return super.get(n(this, t));
+  }
+  has(t) {
+    return super.has(n(this, t));
+  }
+  set(t, s) {
+    return super.set(u(this, t), s);
+  }
+  delete(t) {
+    return super.delete(c(this, t));
+  }
+}
+function n({ _intern: e, _key: t }, s) {
+  const r = t(s);
+  return e.has(r) ? e.get(r) : s;
+}
+function u({ _intern: e, _key: t }, s) {
+  const r = t(s);
+  return e.has(r) ? e.get(r) : (e.set(r, s), s);
+}
+function c({ _intern: e, _key: t }, s) {
+  const r = t(s);
+  return e.has(r) && (s = e.get(r), e.delete(r)), s;
+}
+function f(e) {
+  return e !== null && typeof e == "object" ? e.valueOf() : e;
+}
+export {
+  i as InternMap
+};

package/dist/node_modules/react-is/cjs/react-is.development.js

@@ -0,0 +1,98 @@
+import { __exports as r } from "../../../_virtual/react-is.development.js";
+/** @license React v17.0.2
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var m;
+function ee() {
+  return m ? r : (m = 1, process.env.NODE_ENV !== "production" && (function() {
+    var _ = 60103, v = 60106, n = 60107, c = 60108, i = 60114, s = 60109, o = 60110, u = 60112, f = 60113, R = 60120, E = 60115, d = 60116, l = 60121, P = 60122, A = 60117, x = 60129, M = 60131;
+    if (typeof Symbol == "function" && Symbol.for) {
+      var a = Symbol.for;
+      _ = a("react.element"), v = a("react.portal"), n = a("react.fragment"), c = a("react.strict_mode"), i = a("react.profiler"), s = a("react.provider"), o = a("react.context"), u = a("react.forward_ref"), f = a("react.suspense"), R = a("react.suspense_list"), E = a("react.memo"), d = a("react.lazy"), l = a("react.block"), P = a("react.server.block"), A = a("react.fundamental"), a("react.scope"), a("react.opaque.id"), x = a("react.debug_trace_mode"), a("react.offscreen"), M = a("react.legacy_hidden");
+    }
+    var I = !1;
+    function $(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === n || e === i || e === x || e === c || e === f || e === R || e === M || I || typeof e == "object" && e !== null && (e.$$typeof === d || e.$$typeof === E || e.$$typeof === s || e.$$typeof === o || e.$$typeof === u || e.$$typeof === A || e.$$typeof === l || e[0] === P));
+    }
+    function t(e) {
+      if (typeof e == "object" && e !== null) {
+        var C = e.$$typeof;
+        switch (C) {
+          case _:
+            var T = e.type;
+            switch (T) {
+              case n:
+              case i:
+              case c:
+              case f:
+              case R:
+                return T;
+              default:
+                var Y = T && T.$$typeof;
+                switch (Y) {
+                  case o:
+                  case u:
+                  case d:
+                  case E:
+                  case s:
+                    return Y;
+                  default:
+                    return C;
+                }
+            }
+          case v:
+            return C;
+        }
+      }
+    }
+    var L = o, O = s, w = _, h = u, D = n, N = d, g = E, z = v, V = i, q = c, G = f, S = !1, p = !1;
+    function U(e) {
+      return S || (S = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.")), !1;
+    }
+    function B(e) {
+      return p || (p = !0, console.warn("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.")), !1;
+    }
+    function W(e) {
+      return t(e) === o;
+    }
+    function k(e) {
+      return t(e) === s;
+    }
+    function K(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === _;
+    }
+    function H(e) {
+      return t(e) === u;
+    }
+    function X(e) {
+      return t(e) === n;
+    }
+    function Z(e) {
+      return t(e) === d;
+    }
+    function j(e) {
+      return t(e) === E;
+    }
+    function J(e) {
+      return t(e) === v;
+    }
+    function Q(e) {
+      return t(e) === i;
+    }
+    function b(e) {
+      return t(e) === c;
+    }
+    function F(e) {
+      return t(e) === f;
+    }
+    r.ContextConsumer = L, r.ContextProvider = O, r.Element = w, r.ForwardRef = h, r.Fragment = D, r.Lazy = N, r.Memo = g, r.Portal = z, r.Profiler = V, r.StrictMode = q, r.Suspense = G, r.isAsyncMode = U, r.isConcurrentMode = B, r.isContextConsumer = W, r.isContextProvider = k, r.isElement = K, r.isForwardRef = H, r.isFragment = X, r.isLazy = Z, r.isMemo = j, r.isPortal = J, r.isProfiler = Q, r.isStrictMode = b, r.isSuspense = F, r.isValidElementType = $, r.typeOf = t;
+  })(), r);
+}
+export {
+  ee as __require
+};