@commercetools/nimbus 2.9.1 → 2.11.0

package/dist/chunks/CollectionBuilder-CbqLnlVI.es.js

@@ -0,0 +1,634 @@
+import d, { useMemo as E, cloneElement as X, useContext as C, createContext as w, forwardRef as z, useState as Z, useCallback as x, useRef as ee } from "react";
+import { c as V } from "./useFocusable-Cd_G32KV.es.js";
+import { a as te } from "./Hidden-QDfbcOVE.es.js";
+import { $ as G } from "./SSRProvider-gUjhGHAJ.es.js";
+import { createPortal as ie } from "react-dom";
+class _ {
+  constructor(e) {
+    this.value = null, this.level = 0, this.hasChildNodes = !1, this.rendered = null, this.textValue = "", this["aria-label"] = void 0, this.index = 0, this.parentKey = null, this.prevKey = null, this.nextKey = null, this.firstChildKey = null, this.lastChildKey = null, this.props = {}, this.colSpan = null, this.colIndex = null, this.type = this.constructor.type, this.key = e;
+  }
+  get childNodes() {
+    throw new Error("childNodes is not supported");
+  }
+  clone() {
+    let e = new this.constructor(this.key);
+    return e.value = this.value, e.level = this.level, e.hasChildNodes = this.hasChildNodes, e.rendered = this.rendered, e.textValue = this.textValue, e["aria-label"] = this["aria-label"], e.index = this.index, e.parentKey = this.parentKey, e.prevKey = this.prevKey, e.nextKey = this.nextKey, e.firstChildKey = this.firstChildKey, e.lastChildKey = this.lastChildKey, e.props = this.props, e.render = this.render, e.colSpan = this.colSpan, e.colIndex = this.colIndex, e;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  filter(e, t, n) {
+    let i = this.clone();
+    return t.addDescendants(i, e), i;
+  }
+}
+class W extends _ {
+  filter(e, t, n) {
+    let [i, r] = F(e, t, this.firstChildKey, n), s = this.clone();
+    return s.firstChildKey = i, s.lastChildKey = r, s;
+  }
+}
+const N = class N extends _ {
+};
+N.type = "header";
+let L = N;
+const M = class M extends _ {
+};
+M.type = "loader";
+let A = M;
+const R = class R extends W {
+  filter(e, t, n) {
+    if (n(this.textValue, this)) {
+      let i = this.clone();
+      return t.addDescendants(i, e), i;
+    }
+    return null;
+  }
+};
+R.type = "item";
+let H = R;
+const O = class O extends W {
+  filter(e, t, n) {
+    let i = super.filter(e, t, n);
+    if (i && i.lastChildKey !== null) {
+      let r = e.getItem(i.lastChildKey);
+      if (r && r.type !== "header") return i;
+    }
+    return null;
+  }
+};
+O.type = "section";
+let T = O;
+class ne {
+  get size() {
+    return this.itemCount;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  *[Symbol.iterator]() {
+    let e = this.firstKey != null ? this.keyMap.get(this.firstKey) : void 0;
+    for (; e; )
+      yield e, e = e.nextKey != null ? this.keyMap.get(e.nextKey) : void 0;
+  }
+  getChildren(e) {
+    let t = this.keyMap;
+    return {
+      *[Symbol.iterator]() {
+        let n = t.get(e), i = n?.firstChildKey != null ? t.get(n.firstChildKey) : null;
+        for (; i; )
+          yield i, i = i.nextKey != null ? t.get(i.nextKey) : void 0;
+      }
+    };
+  }
+  getKeyBefore(e) {
+    let t = this.keyMap.get(e);
+    if (!t) return null;
+    if (t.prevKey != null) {
+      for (t = this.keyMap.get(t.prevKey); t && t.type !== "item" && t.lastChildKey != null; ) t = this.keyMap.get(t.lastChildKey);
+      return t?.key ?? null;
+    }
+    return t.parentKey;
+  }
+  getKeyAfter(e) {
+    let t = this.keyMap.get(e);
+    if (!t) return null;
+    if (t.type !== "item" && t.firstChildKey != null) return t.firstChildKey;
+    for (; t; ) {
+      if (t.nextKey != null) return t.nextKey;
+      if (t.parentKey != null) t = this.keyMap.get(t.parentKey);
+      else return null;
+    }
+    return null;
+  }
+  getFirstKey() {
+    return this.firstKey;
+  }
+  getLastKey() {
+    let e = this.lastKey != null ? this.keyMap.get(this.lastKey) : null;
+    for (; e?.lastChildKey != null; ) e = this.keyMap.get(e.lastChildKey);
+    return e?.key ?? null;
+  }
+  getItem(e) {
+    return this.keyMap.get(e) ?? null;
+  }
+  at() {
+    throw new Error("Not implemented");
+  }
+  clone() {
+    let e = this.constructor, t = new e();
+    return t.keyMap = new Map(this.keyMap), t.firstKey = this.firstKey, t.lastKey = this.lastKey, t.itemCount = this.itemCount, t;
+  }
+  addNode(e) {
+    if (this.frozen) throw new Error("Cannot add a node to a frozen collection");
+    e.type === "item" && this.keyMap.get(e.key) == null && this.itemCount++, this.keyMap.set(e.key, e);
+  }
+  // Deeply add a node and its children to the collection from another collection, primarily used when filtering a collection
+  addDescendants(e, t) {
+    this.addNode(e);
+    let n = t.getChildren(e.key);
+    for (let i of n) this.addDescendants(i, t);
+  }
+  removeNode(e) {
+    if (this.frozen) throw new Error("Cannot remove a node to a frozen collection");
+    let t = this.keyMap.get(e);
+    t != null && t.type === "item" && this.itemCount--, this.keyMap.delete(e);
+  }
+  commit(e, t, n = !1) {
+    if (this.frozen) throw new Error("Cannot commit a frozen collection");
+    this.firstKey = e, this.lastKey = t, this.frozen = !n;
+  }
+  filter(e) {
+    let t = new this.constructor(), [n, i] = F(this, t, this.firstKey, e);
+    return t?.commit(n, i), t;
+  }
+  constructor() {
+    this.keyMap = /* @__PURE__ */ new Map(), this.firstKey = null, this.lastKey = null, this.frozen = !1, this.itemCount = 0;
+  }
+}
+function F(l, e, t, n) {
+  if (t == null) return [
+    null,
+    null
+  ];
+  let i = null, r = null, s = l.getItem(t);
+  for (; s != null; ) {
+    let o = s.filter(l, e, n);
+    o != null && (o.nextKey = null, r && (o.prevKey = r.key, r.nextKey = o.key), i == null && (i = o), e.addNode(o), r = o), s = s.nextKey ? l.getItem(s.nextKey) : null;
+  }
+  if (r && r.type === "separator") {
+    let o = r.prevKey;
+    e.removeNode(r.key), o ? (r = e.getItem(o), r.nextKey = null) : r = null;
+  }
+  return [
+    i?.key ?? null,
+    r?.key ?? null
+  ];
+}
+class j {
+  constructor(e) {
+    this._firstChild = null, this._lastChild = null, this._previousSibling = null, this._nextSibling = null, this._parentNode = null, this._minInvalidChildIndex = null, this.ownerDocument = e;
+  }
+  *[Symbol.iterator]() {
+    let e = this.firstChild;
+    for (; e; )
+      yield e, e = e.nextSibling;
+  }
+  get firstChild() {
+    return this._firstChild;
+  }
+  set firstChild(e) {
+    this._firstChild = e, this.ownerDocument.markDirty(this);
+  }
+  get lastChild() {
+    return this._lastChild;
+  }
+  set lastChild(e) {
+    this._lastChild = e, this.ownerDocument.markDirty(this);
+  }
+  get previousSibling() {
+    return this._previousSibling;
+  }
+  set previousSibling(e) {
+    this._previousSibling = e, this.ownerDocument.markDirty(this);
+  }
+  get nextSibling() {
+    return this._nextSibling;
+  }
+  set nextSibling(e) {
+    this._nextSibling = e, this.ownerDocument.markDirty(this);
+  }
+  get parentNode() {
+    return this._parentNode;
+  }
+  set parentNode(e) {
+    this._parentNode = e, this.ownerDocument.markDirty(this);
+  }
+  get isConnected() {
+    return this.parentNode?.isConnected || !1;
+  }
+  invalidateChildIndices(e) {
+    (this._minInvalidChildIndex == null || !this._minInvalidChildIndex.isConnected || e.index < this._minInvalidChildIndex.index) && (this._minInvalidChildIndex = e, this.ownerDocument.markDirty(this));
+  }
+  updateChildIndices() {
+    let e = this._minInvalidChildIndex;
+    for (; e; )
+      e.index = e.previousSibling ? e.previousSibling.index + 1 : 0, e = e.nextSibling;
+    this._minInvalidChildIndex = null;
+  }
+  appendChild(e) {
+    e.parentNode && e.parentNode.removeChild(e), this.firstChild == null && (this.firstChild = e), this.lastChild ? (this.lastChild.nextSibling = e, e.index = this.lastChild.index + 1, e.previousSibling = this.lastChild) : (e.previousSibling = null, e.index = 0), e.parentNode = this, e.nextSibling = null, this.lastChild = e, this.ownerDocument.markDirty(this), this.isConnected && this.ownerDocument.queueUpdate();
+  }
+  insertBefore(e, t) {
+    if (t == null) return this.appendChild(e);
+    e.parentNode && e.parentNode.removeChild(e), e.nextSibling = t, e.previousSibling = t.previousSibling, e.index = t.index - 1, this.firstChild === t ? this.firstChild = e : t.previousSibling && (t.previousSibling.nextSibling = e), t.previousSibling = e, e.parentNode = t.parentNode, this.invalidateChildIndices(e), this.isConnected && this.ownerDocument.queueUpdate();
+  }
+  removeChild(e) {
+    e.parentNode === this && (this._minInvalidChildIndex === e && (this._minInvalidChildIndex = null), e.nextSibling && (this.invalidateChildIndices(e.nextSibling), e.nextSibling.previousSibling = e.previousSibling), e.previousSibling && (e.previousSibling.nextSibling = e.nextSibling), this.firstChild === e && (this.firstChild = e.nextSibling), this.lastChild === e && (this.lastChild = e.previousSibling), e.parentNode = null, e.nextSibling = null, e.previousSibling = null, e.index = 0, this.ownerDocument.markDirty(e), this.isConnected && this.ownerDocument.queueUpdate());
+  }
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  get previousVisibleSibling() {
+    let e = this.previousSibling;
+    for (; e && e.isHidden; ) e = e.previousSibling;
+    return e;
+  }
+  get nextVisibleSibling() {
+    let e = this.nextSibling;
+    for (; e && e.isHidden; ) e = e.nextSibling;
+    return e;
+  }
+  get firstVisibleChild() {
+    let e = this.firstChild;
+    for (; e && e.isHidden; ) e = e.nextSibling;
+    return e;
+  }
+  get lastVisibleChild() {
+    let e = this.lastChild;
+    for (; e && e.isHidden; ) e = e.previousSibling;
+    return e;
+  }
+}
+class v extends j {
+  constructor(e, t) {
+    super(t), this.nodeType = 8, this.isMutated = !0, this._index = 0, this.isHidden = !1, this.node = null;
+  }
+  get index() {
+    return this._index;
+  }
+  set index(e) {
+    this._index = e, this.ownerDocument.markDirty(this);
+  }
+  get level() {
+    return this.parentNode instanceof v ? this.parentNode.level + (this.parentNode.node?.type === "item" ? 1 : 0) : 0;
+  }
+  /**
+  * Lazily gets a mutable instance of a Node. If the node has already
+  * been cloned during this update cycle, it just returns the existing one.
+  */
+  getMutableNode() {
+    return this.node == null ? null : (this.isMutated || (this.node = this.node.clone(), this.isMutated = !0), this.ownerDocument.markDirty(this), this.node);
+  }
+  updateNode() {
+    let e = this.nextVisibleSibling, t = this.getMutableNode();
+    if (t != null && (t.index = this.index, t.level = this.level, t.parentKey = this.parentNode instanceof v ? this.parentNode.node?.key ?? null : null, t.prevKey = this.previousVisibleSibling?.node?.key ?? null, t.nextKey = e?.node?.key ?? null, t.hasChildNodes = !!this.firstChild, t.firstChildKey = this.firstVisibleChild?.node?.key ?? null, t.lastChildKey = this.lastVisibleChild?.node?.key ?? null, (t.colSpan != null || t.colIndex != null) && e)) {
+      let n = (t.colIndex ?? t.index) + (t.colSpan ?? 1);
+      if (e.node != null && n !== e.node.colIndex) {
+        let i = e.getMutableNode();
+        i.colIndex = n;
+      }
+    }
+  }
+  setProps(e, t, n, i, r) {
+    let s, { value: o, textValue: a, id: y, ...h } = e;
+    if (this.node == null ? (s = new n(y ?? `react-aria-${++this.ownerDocument.nodeId}`), this.node = s) : s = this.getMutableNode(), h.ref = t, s.props = h, s.rendered = i, s.render = r, s.value = o, e["aria-label"] && (s["aria-label"] = e["aria-label"]), s.textValue = a || (typeof h.children == "string" ? h.children : "") || e["aria-label"] || "", y != null && y !== s.key) throw new Error("Cannot change the id of an item");
+    h.colSpan != null && (s.colSpan = h.colSpan), this.isConnected && this.ownerDocument.queueUpdate();
+  }
+  get style() {
+    let e = this;
+    return {
+      get display() {
+        return e.isHidden ? "none" : "";
+      },
+      set display(t) {
+        let n = t === "none";
+        if (e.isHidden !== n) {
+          (e.parentNode?.firstVisibleChild === e || e.parentNode?.lastVisibleChild === e) && e.ownerDocument.markDirty(e.parentNode);
+          let i = e.previousVisibleSibling, r = e.nextVisibleSibling;
+          i && e.ownerDocument.markDirty(i), r && e.ownerDocument.markDirty(r), e.isHidden = n, e.ownerDocument.markDirty(e);
+        }
+      }
+    };
+  }
+  hasAttribute() {
+  }
+  setAttribute() {
+  }
+  setAttributeNS() {
+  }
+  removeAttribute() {
+  }
+}
+class le extends j {
+  constructor(e) {
+    super(null), this.nodeType = 11, this.ownerDocument = this, this.dirtyNodes = /* @__PURE__ */ new Set(), this.isSSR = !1, this.nodeId = 0, this.nodesByProps = /* @__PURE__ */ new WeakMap(), this.nextCollection = null, this.subscriptions = /* @__PURE__ */ new Set(), this.queuedRender = !1, this.inSubscription = !1, this.collection = e, this.nextCollection = e;
+  }
+  get isConnected() {
+    return !0;
+  }
+  createElement(e) {
+    return new v(e, this);
+  }
+  getMutableCollection() {
+    return this.nextCollection || (this.nextCollection = this.collection.clone()), this.nextCollection;
+  }
+  markDirty(e) {
+    this.dirtyNodes.add(e);
+  }
+  addNode(e) {
+    if (e.isHidden || e.node == null) return;
+    let t = this.getMutableCollection();
+    if (!t.getItem(e.node.key)) for (let n of e) this.addNode(n);
+    t.addNode(e.node);
+  }
+  removeNode(e) {
+    for (let t of e) this.removeNode(t);
+    e.node && this.getMutableCollection().removeNode(e.node.key);
+  }
+  /** Finalizes the collection update, updating all nodes and freezing the collection. */
+  getCollection() {
+    return this.inSubscription ? this.collection : (this.queuedRender = !1, this.updateCollection(), this.collection);
+  }
+  updateCollection() {
+    for (let e of this.dirtyNodes) e instanceof v && (!e.isConnected || e.isHidden) ? this.removeNode(e) : e.updateChildIndices();
+    for (let e of this.dirtyNodes) e instanceof v ? (e.isConnected && !e.isHidden && (e.updateNode(), this.addNode(e)), e.node && this.dirtyNodes.delete(e), e.isMutated = !1) : this.dirtyNodes.delete(e);
+    this.nextCollection && (this.nextCollection.commit(this.firstVisibleChild?.node?.key ?? null, this.lastVisibleChild?.node?.key ?? null, this.isSSR), this.isSSR || (this.collection = this.nextCollection, this.nextCollection = null));
+  }
+  queueUpdate() {
+    if (!(this.dirtyNodes.size === 0 || this.queuedRender)) {
+      this.queuedRender = !0, this.inSubscription = !0, this.isSSR || (this.collection = this.collection.clone());
+      for (let e of this.subscriptions) e();
+      this.inSubscription = !1;
+    }
+  }
+  subscribe(e) {
+    return this.subscriptions.add(e), () => this.subscriptions.delete(e);
+  }
+  resetAfterSSR() {
+    this.isSSR && (this.isSSR = !1, this.firstChild = null, this.lastChild = null, this.nodeId = 0);
+  }
+}
+function re(l) {
+  let { children: e, items: t, idScope: n, addIdAndValue: i, dependencies: r = [] } = l, s = E(() => /* @__PURE__ */ new WeakMap(), r);
+  return E(() => {
+    if (t && typeof e == "function") {
+      let o = [];
+      for (let a of t) {
+        let y = s.get(a);
+        if (!y) {
+          y = e(a);
+          let h = y.props.id ?? a.key ?? a.id;
+          if (h == null) throw new Error("Could not determine key for item");
+          n != null && y.props.id == null && (h = n + ":" + h), y = X(y, i ? {
+            key: h,
+            id: h,
+            value: a
+          } : {
+            key: h
+          }), s.set(a, y);
+        }
+        o.push(y);
+      }
+      return o;
+    } else if (typeof e != "function") return e;
+  }, [
+    e,
+    t,
+    s,
+    n,
+    i
+  ]);
+}
+var K = { exports: {} }, $ = {};
+var q;
+function se() {
+  if (q) return $;
+  q = 1;
+  var l = d;
+  function e(c, S) {
+    return c === S && (c !== 0 || 1 / c === 1 / S) || c !== c && S !== S;
+  }
+  var t = typeof Object.is == "function" ? Object.is : e, n = l.useState, i = l.useEffect, r = l.useLayoutEffect, s = l.useDebugValue;
+  function o(c, S) {
+    var u = S(), f = n({ inst: { value: u, getSnapshot: S } }), p = f[0].inst, m = f[1];
+    return r(
+      function() {
+        p.value = u, p.getSnapshot = S, a(p) && m({ inst: p });
+      },
+      [c, u, S]
+    ), i(
+      function() {
+        return a(p) && m({ inst: p }), c(function() {
+          a(p) && m({ inst: p });
+        });
+      },
+      [c]
+    ), s(u), u;
+  }
+  function a(c) {
+    var S = c.getSnapshot;
+    c = c.value;
+    try {
+      var u = S();
+      return !t(c, u);
+    } catch {
+      return !0;
+    }
+  }
+  function y(c, S) {
+    return S();
+  }
+  var h = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? y : o;
+  return $.useSyncExternalStore = l.useSyncExternalStore !== void 0 ? l.useSyncExternalStore : h, $;
+}
+var D = {};
+var P;
+function oe() {
+  return P || (P = 1, process.env.NODE_ENV !== "production" && (function() {
+    function l(u, f) {
+      return u === f && (u !== 0 || 1 / u === 1 / f) || u !== u && f !== f;
+    }
+    function e(u, f) {
+      h || i.startTransition === void 0 || (h = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var p = f();
+      if (!c) {
+        var m = f();
+        r(p, m) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), c = !0);
+      }
+      m = s({
+        inst: { value: p, getSnapshot: f }
+      });
+      var b = m[0].inst, k = m[1];
+      return a(
+        function() {
+          b.value = p, b.getSnapshot = f, t(b) && k({ inst: b });
+        },
+        [u, p, f]
+      ), o(
+        function() {
+          return t(b) && k({ inst: b }), u(function() {
+            t(b) && k({ inst: b });
+          });
+        },
+        [u]
+      ), y(p), p;
+    }
+    function t(u) {
+      var f = u.getSnapshot;
+      u = u.value;
+      try {
+        var p = f();
+        return !r(u, p);
+      } catch {
+        return !0;
+      }
+    }
+    function n(u, f) {
+      return f();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var i = d, r = typeof Object.is == "function" ? Object.is : l, s = i.useState, o = i.useEffect, a = i.useLayoutEffect, y = i.useDebugValue, h = !1, c = !1, S = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? n : e;
+    D.useSyncExternalStore = i.useSyncExternalStore !== void 0 ? i.useSyncExternalStore : S, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), D;
+}
+var U;
+function ae() {
+  return U || (U = 1, process.env.NODE_ENV === "production" ? K.exports = se() : K.exports = oe()), K.exports;
+}
+var ue = /* @__PURE__ */ ae();
+const J = /* @__PURE__ */ w(!1), g = /* @__PURE__ */ w(null);
+function xe(l) {
+  if (C(g))
+    return l.content;
+  let { collection: t, document: n } = fe(l.createCollection);
+  return /* @__PURE__ */ d.createElement(d.Fragment, null, /* @__PURE__ */ d.createElement(te, null, /* @__PURE__ */ d.createElement(g.Provider, {
+    value: n
+  }, l.content)), /* @__PURE__ */ d.createElement(de, {
+    render: l.children,
+    collection: t
+  }));
+}
+function de({ collection: l, render: e }) {
+  return e(l);
+}
+function he(l, e, t) {
+  let n = G(), i = ee(n);
+  i.current = n;
+  let r = x(() => i.current ? t() : e(), [
+    e,
+    t
+  ]);
+  return ue.useSyncExternalStore(l, r);
+}
+const ce = typeof d.useSyncExternalStore == "function" ? d.useSyncExternalStore : he;
+function fe(l) {
+  let [e] = Z(() => new le(l?.() || new ne())), t = x((s) => e.subscribe(s), [
+    e
+  ]), n = x(() => {
+    let s = e.getCollection();
+    return e.isSSR && e.resetAfterSSR(), s;
+  }, [
+    e
+  ]), i = x(() => (e.isSSR = !0, e.getCollection()), [
+    e
+  ]);
+  return {
+    collection: ce(t, n, i),
+    document: e
+  };
+}
+const I = /* @__PURE__ */ w(null);
+function pe(l) {
+  var t;
+  return t = class extends _ {
+  }, t.type = l, t;
+}
+function Y(l, e, t, n, i, r) {
+  typeof l == "string" && (l = pe(l));
+  let s = x((a) => {
+    a?.setProps(e, t, l, n, r);
+  }, [
+    e,
+    t,
+    n,
+    r,
+    l
+  ]), o = C(I);
+  if (o) {
+    let a = o.ownerDocument.nodesByProps.get(e);
+    return a || (a = o.ownerDocument.createElement(l.type), a.setProps(e, t, l, n, r), o.appendChild(a), o.ownerDocument.updateCollection(), o.ownerDocument.nodesByProps.set(e, a)), i ? /* @__PURE__ */ d.createElement(I.Provider, {
+      value: a
+    }, i) : null;
+  }
+  return /* @__PURE__ */ d.createElement(l.type, {
+    ref: s
+  }, i);
+}
+function ge(l, e) {
+  let t = ({ node: i }) => e(i.props, i.props.ref, i), n = z((i, r) => {
+    let s = C(V);
+    if (!C(J)) {
+      if (e.length >= 3) throw new Error(e.name + " cannot be rendered outside a collection.");
+      return e(i, r);
+    }
+    return Y(l, i, r, "children" in i ? i.children : null, null, (a) => /* @__PURE__ */ d.createElement(V.Provider, {
+      value: s
+    }, /* @__PURE__ */ d.createElement(t, {
+      node: a
+    })));
+  });
+  return n.displayName = e.name, n;
+}
+function Ke(l, e, t = Q) {
+  let n = ({ node: r }) => e(r.props, r.props.ref, r), i = z((r, s) => {
+    let o = t(r);
+    return Y(l, r, s, null, o, (a) => /* @__PURE__ */ d.createElement(n, {
+      node: a
+    })) ?? /* @__PURE__ */ d.createElement(d.Fragment, null);
+  });
+  return i.displayName = e.name, i;
+}
+function Q(l) {
+  return re({
+    ...l,
+    addIdAndValue: !0
+  });
+}
+const B = /* @__PURE__ */ w(null);
+function Ee(l) {
+  let e = C(B), t = (e?.dependencies || []).concat(l.dependencies), n = l.idScope ?? e?.idScope, i = Q({
+    ...l,
+    idScope: n,
+    dependencies: t
+  });
+  return C(g) && (i = /* @__PURE__ */ d.createElement(ye, null, i)), e = E(() => ({
+    dependencies: t,
+    idScope: n
+  }), [
+    n,
+    ...t
+  ]), /* @__PURE__ */ d.createElement(B.Provider, {
+    value: e
+  }, i);
+}
+function ye({ children: l }) {
+  let e = C(g), t = E(() => /* @__PURE__ */ d.createElement(g.Provider, {
+    value: null
+  }, /* @__PURE__ */ d.createElement(J.Provider, {
+    value: !0
+  }, l)), [
+    l
+  ]);
+  return G() ? /* @__PURE__ */ d.createElement(I.Provider, {
+    value: e
+  }, t) : /* @__PURE__ */ ie(t, e);
+}
+export {
+  ge as $,
+  _ as a,
+  L as b,
+  Ke as c,
+  T as d,
+  H as e,
+  xe as f,
+  Ee as g,
+  A as h,
+  re as i,
+  W as j,
+  ne as k
+};
+//# sourceMappingURL=CollectionBuilder-CbqLnlVI.es.js.map