@manafishrov/ui 1.5.0 → 1.5.2

package/dist/node_modules/.bun/@zag-js_collection@1.38.2/node_modules/@zag-js/collection/dist/tree-collection.js

@@ -0,0 +1,272 @@
+import { isEqual as e } from "../../../../../@zag-js_utils@1.38.2/node_modules/@zag-js/utils/dist/equal.js";
+import { hasProp as t, isObject as n } from "../../../../../@zag-js_utils@1.38.2/node_modules/@zag-js/utils/dist/guard.js";
+import { __publicField as r } from "./chunk-QZ7TP4HQ.js";
+import { access as i, compareIndexPaths as a, filter as o, find as s, findAll as c, findIndexPath as l, flatMap as u, flatten as d, insert as f, move as p, remove as m, replace as h, visit as g } from "./tree-visit.js";
+//#region ../../node_modules/.bun/@zag-js+collection@1.38.2/node_modules/@zag-js/collection/dist/tree-collection.mjs
+var _ = class t {
+	constructor(n) {
+		this.options = n, r(this, "rootNode"), r(this, "isEqual", (t) => e(this.rootNode, t.rootNode)), r(this, "getNodeChildren", (e) => this.options.nodeToChildren?.(e) ?? y.nodeToChildren(e) ?? []), r(this, "resolveIndexPath", (e) => typeof e == "string" ? this.getIndexPath(e) : e), r(this, "resolveNode", (e) => {
+			let t = this.resolveIndexPath(e);
+			return t ? this.at(t) : void 0;
+		}), r(this, "getNodeChildrenCount", (e) => this.options.nodeToChildrenCount?.(e) ?? y.nodeToChildrenCount(e)), r(this, "getNodeValue", (e) => this.options.nodeToValue?.(e) ?? y.nodeToValue(e)), r(this, "getNodeDisabled", (e) => this.options.isNodeDisabled?.(e) ?? y.isNodeDisabled(e)), r(this, "stringify", (e) => {
+			let t = this.findNode(e);
+			return t ? this.stringifyNode(t) : null;
+		}), r(this, "stringifyNode", (e) => this.options.nodeToString?.(e) ?? y.nodeToString(e)), r(this, "getFirstNode", (e = this.rootNode, t = {}) => {
+			let n;
+			return g(e, {
+				getChildren: this.getNodeChildren,
+				onEnter: (r, i) => {
+					if (!this.isSameNode(r, e)) {
+						if (t.skip?.({
+							value: this.getNodeValue(r),
+							node: r,
+							indexPath: i
+						})) return "skip";
+						if (!n && i.length > 0 && !this.getNodeDisabled(r)) return n = r, "stop";
+					}
+				}
+			}), n;
+		}), r(this, "getLastNode", (e = this.rootNode, t = {}) => {
+			let n;
+			return g(e, {
+				getChildren: this.getNodeChildren,
+				onEnter: (r, i) => {
+					if (!this.isSameNode(r, e)) {
+						if (t.skip?.({
+							value: this.getNodeValue(r),
+							node: r,
+							indexPath: i
+						})) return "skip";
+						i.length > 0 && !this.getNodeDisabled(r) && (n = r);
+					}
+				}
+			}), n;
+		}), r(this, "at", (e) => i(this.rootNode, e, { getChildren: this.getNodeChildren })), r(this, "findNode", (e, t = this.rootNode) => s(t, {
+			getChildren: this.getNodeChildren,
+			predicate: (t) => this.getNodeValue(t) === e
+		})), r(this, "findNodes", (e, t = this.rootNode) => {
+			let n = new Set(e.filter((e) => e != null));
+			return c(t, {
+				getChildren: this.getNodeChildren,
+				predicate: (e) => n.has(this.getNodeValue(e))
+			});
+		}), r(this, "sort", (e) => e.reduce((e, t) => {
+			let n = this.getIndexPath(t);
+			return n && e.push({
+				value: t,
+				indexPath: n
+			}), e;
+		}, []).sort((e, t) => a(e.indexPath, t.indexPath)).map(({ value: e }) => e)), r(this, "getValue", (e) => {
+			let t = this.at(e);
+			return t ? this.getNodeValue(t) : void 0;
+		}), r(this, "getValuePath", (e) => {
+			if (!e) return [];
+			let t = [], n = [...e];
+			for (; n.length > 0;) {
+				let e = this.at(n);
+				e && t.unshift(this.getNodeValue(e)), n.pop();
+			}
+			return t;
+		}), r(this, "getDepth", (e) => l(this.rootNode, {
+			getChildren: this.getNodeChildren,
+			predicate: (t) => this.getNodeValue(t) === e
+		})?.length ?? 0), r(this, "isSameNode", (e, t) => this.getNodeValue(e) === this.getNodeValue(t)), r(this, "isRootNode", (e) => this.isSameNode(e, this.rootNode)), r(this, "contains", (e, t) => !e || !t ? !1 : t.slice(0, e.length).every((n, r) => e[r] === t[r])), r(this, "getNextNode", (e, t = {}) => {
+			let n = !1, r;
+			return g(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (i, a) => {
+					if (this.isRootNode(i)) return;
+					let o = this.getNodeValue(i);
+					if (t.skip?.({
+						value: o,
+						node: i,
+						indexPath: a
+					})) return o === e && (n = !0), "skip";
+					if (n && !this.getNodeDisabled(i)) return r = i, "stop";
+					o === e && (n = !0);
+				}
+			}), r;
+		}), r(this, "getPreviousNode", (e, t = {}) => {
+			let n, r = !1;
+			return g(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (i, a) => {
+					if (this.isRootNode(i)) return;
+					let o = this.getNodeValue(i);
+					if (t.skip?.({
+						value: o,
+						node: i,
+						indexPath: a
+					})) return "skip";
+					if (o === e) return r = !0, "stop";
+					this.getNodeDisabled(i) || (n = i);
+				}
+			}), r ? n : void 0;
+		}), r(this, "getParentNodes", (e) => {
+			let t = this.resolveIndexPath(e)?.slice();
+			if (!t) return [];
+			let n = [];
+			for (; t.length > 0;) {
+				t.pop();
+				let e = this.at(t);
+				e && !this.isRootNode(e) && n.unshift(e);
+			}
+			return n;
+		}), r(this, "getDescendantNodes", (e, t) => {
+			let n = this.resolveNode(e);
+			if (!n) return [];
+			let r = [];
+			return g(n, {
+				getChildren: this.getNodeChildren,
+				onEnter: (e, n) => {
+					n.length !== 0 && (!t?.withBranch && this.isBranchNode(e) || r.push(e));
+				}
+			}), r;
+		}), r(this, "getDescendantValues", (e, t) => this.getDescendantNodes(e, t).map((e) => this.getNodeValue(e))), r(this, "getParentIndexPath", (e) => e.slice(0, -1)), r(this, "getParentNode", (e) => {
+			let t = this.resolveIndexPath(e);
+			return t ? this.at(this.getParentIndexPath(t)) : void 0;
+		}), r(this, "visit", (e) => {
+			let { skip: t, ...n } = e;
+			g(this.rootNode, {
+				...n,
+				getChildren: this.getNodeChildren,
+				onEnter: (e, r) => {
+					if (!this.isRootNode(e)) return t?.({
+						value: this.getNodeValue(e),
+						node: e,
+						indexPath: r
+					}) ? "skip" : n.onEnter?.(e, r);
+				}
+			});
+		}), r(this, "getPreviousSibling", (e) => {
+			let t = this.getParentNode(e);
+			if (!t) return;
+			let n = this.getNodeChildren(t), r = e[e.length - 1];
+			for (; --r >= 0;) {
+				let e = n[r];
+				if (!this.getNodeDisabled(e)) return e;
+			}
+		}), r(this, "getNextSibling", (e) => {
+			let t = this.getParentNode(e);
+			if (!t) return;
+			let n = this.getNodeChildren(t), r = e[e.length - 1];
+			for (; ++r < n.length;) {
+				let e = n[r];
+				if (!this.getNodeDisabled(e)) return e;
+			}
+		}), r(this, "getSiblingNodes", (e) => {
+			let t = this.getParentNode(e);
+			return t ? this.getNodeChildren(t) : [];
+		}), r(this, "getValues", (e = this.rootNode) => u(e, {
+			getChildren: this.getNodeChildren,
+			transform: (e) => [this.getNodeValue(e)]
+		}).slice(1)), r(this, "isValidDepth", (e, t) => t == null ? !0 : typeof t == "function" ? t(e.length) : e.length === t), r(this, "isBranchNode", (e) => this.getNodeChildren(e).length > 0 || this.getNodeChildrenCount(e) != null), r(this, "getBranchValues", (e = this.rootNode, t = {}) => {
+			let n = [];
+			return g(e, {
+				getChildren: this.getNodeChildren,
+				onEnter: (e, r) => {
+					if (r.length === 0) return;
+					let i = this.getNodeValue(e);
+					if (t.skip?.({
+						value: i,
+						node: e,
+						indexPath: r
+					})) return "skip";
+					this.isBranchNode(e) && this.isValidDepth(r, t.depth) && n.push(this.getNodeValue(e));
+				}
+			}), n;
+		}), r(this, "flatten", (e = this.rootNode) => d(e, { getChildren: this.getNodeChildren })), r(this, "_create", (e, t) => this.getNodeChildren(e).length > 0 || t.length > 0 ? {
+			...e,
+			children: t
+		} : { ...e }), r(this, "_insert", (e, t, n) => this.copy(f(e, {
+			at: t,
+			nodes: n,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), r(this, "copy", (e) => new t({
+			...this.options,
+			rootNode: e
+		})), r(this, "_replace", (e, t, n) => this.copy(h(e, {
+			at: t,
+			node: n,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), r(this, "_move", (e, t, n) => this.copy(p(e, {
+			indexPaths: t,
+			to: n,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), r(this, "_remove", (e, t) => this.copy(m(e, {
+			indexPaths: t,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), r(this, "replace", (e, t) => this._replace(this.rootNode, e, t)), r(this, "remove", (e) => this._remove(this.rootNode, e)), r(this, "insertBefore", (e, t) => this.getParentNode(e) ? this._insert(this.rootNode, e, t) : void 0), r(this, "insertAfter", (e, t) => {
+			if (!this.getParentNode(e)) return;
+			let n = [...e.slice(0, -1), e[e.length - 1] + 1];
+			return this._insert(this.rootNode, n, t);
+		}), r(this, "move", (e, t) => this._move(this.rootNode, e, t)), r(this, "filter", (e) => {
+			let t = o(this.rootNode, {
+				predicate: e,
+				getChildren: this.getNodeChildren,
+				create: this._create
+			});
+			return this.copy(t);
+		}), r(this, "toJSON", () => this.getValues(this.rootNode)), this.rootNode = n.rootNode;
+	}
+	getIndexPath(e) {
+		if (Array.isArray(e)) {
+			if (e.length === 0) return [];
+			let t = [], n = this.getNodeChildren(this.rootNode);
+			for (let r = 0; r < e.length; r++) {
+				let i = e[r], a = n.findIndex((e) => this.getNodeValue(e) === i);
+				if (a === -1) break;
+				if (t.push(a), r < e.length - 1) {
+					let e = n[a];
+					n = this.getNodeChildren(e);
+				}
+			}
+			return t;
+		} else return l(this.rootNode, {
+			getChildren: this.getNodeChildren,
+			predicate: (t) => this.getNodeValue(t) === e
+		});
+	}
+};
+function v(e) {
+	let t = {
+		label: "",
+		value: "ROOT",
+		children: []
+	};
+	return e.forEach((e) => {
+		let n = e.split("/"), r = t;
+		n.forEach((e, t) => {
+			let i = r.children?.find((t) => t.label === e);
+			i || (i = {
+				value: n.slice(0, t + 1).join("/"),
+				label: e
+			}, r.children ||= [], r.children.push(i)), r = i;
+		});
+	}), new _({ rootNode: t });
+}
+var y = {
+	nodeToValue(e) {
+		return typeof e == "string" ? e : n(e) && t(e, "value") ? e.value : "";
+	},
+	nodeToString(e) {
+		return typeof e == "string" ? e : n(e) && t(e, "label") ? e.label : y.nodeToValue(e);
+	},
+	isNodeDisabled(e) {
+		return n(e) && t(e, "disabled") ? !!e.disabled : !1;
+	},
+	nodeToChildren(e) {
+		return e.children;
+	},
+	nodeToChildrenCount(e) {
+		if (n(e) && t(e, "childrenCount")) return e.childrenCount;
+	}
+};
+//#endregion
+export { _ as TreeCollection, v as filePathToTree };
+
+//# sourceMappingURL=tree-collection.js.map

package/dist/node_modules/.bun/@zag-js_collection@1.38.2/node_modules/@zag-js/collection/dist/tree-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-collection.js","names":[],"sources":["../../../../../../../../../../node_modules/.bun/@zag-js+collection@1.38.2/node_modules/@zag-js/collection/dist/tree-collection.mjs"],"sourcesContent":["import {\n  __publicField\n} from \"./chunk-QZ7TP4HQ.mjs\";\n\n// src/tree-collection.ts\nimport { hasProp, isEqual, isObject } from \"@zag-js/utils\";\nimport {\n  access,\n  compareIndexPaths,\n  filter,\n  find,\n  findAll,\n  findIndexPath,\n  flatMap,\n  flatten,\n  insert,\n  move,\n  remove,\n  replace,\n  visit\n} from \"./tree-visit.mjs\";\nvar TreeCollection = class _TreeCollection {\n  constructor(options) {\n    this.options = options;\n    __publicField(this, \"rootNode\");\n    __publicField(this, \"isEqual\", (other) => {\n      return isEqual(this.rootNode, other.rootNode);\n    });\n    __publicField(this, \"getNodeChildren\", (node) => {\n      return this.options.nodeToChildren?.(node) ?? fallbackMethods.nodeToChildren(node) ?? [];\n    });\n    __publicField(this, \"resolveIndexPath\", (valueOrIndexPath) => {\n      return typeof valueOrIndexPath === \"string\" ? this.getIndexPath(valueOrIndexPath) : valueOrIndexPath;\n    });\n    __publicField(this, \"resolveNode\", (valueOrIndexPath) => {\n      const indexPath = this.resolveIndexPath(valueOrIndexPath);\n      return indexPath ? this.at(indexPath) : void 0;\n    });\n    __publicField(this, \"getNodeChildrenCount\", (node) => {\n      return this.options.nodeToChildrenCount?.(node) ?? fallbackMethods.nodeToChildrenCount(node);\n    });\n    __publicField(this, \"getNodeValue\", (node) => {\n      return this.options.nodeToValue?.(node) ?? fallbackMethods.nodeToValue(node);\n    });\n    __publicField(this, \"getNodeDisabled\", (node) => {\n      return this.options.isNodeDisabled?.(node) ?? fallbackMethods.isNodeDisabled(node);\n    });\n    __publicField(this, \"stringify\", (value) => {\n      const node = this.findNode(value);\n      if (!node) return null;\n      return this.stringifyNode(node);\n    });\n    __publicField(this, \"stringifyNode\", (node) => {\n      return this.options.nodeToString?.(node) ?? fallbackMethods.nodeToString(node);\n    });\n    __publicField(this, \"getFirstNode\", (rootNode = this.rootNode, opts = {}) => {\n      let firstChild;\n      visit(rootNode, {\n        getChildren: this.getNodeChildren,\n        onEnter: (node, indexPath) => {\n          if (this.isSameNode(node, rootNode)) return;\n          if (opts.skip?.({ value: this.getNodeValue(node), node, indexPath })) return \"skip\";\n          if (!firstChild && indexPath.length > 0 && !this.getNodeDisabled(node)) {\n            firstChild = node;\n            return \"stop\";\n          }\n        }\n      });\n      return firstChild;\n    });\n    __publicField(this, \"getLastNode\", (rootNode = this.rootNode, opts = {}) => {\n      let lastChild;\n      visit(rootNode, {\n        getChildren: this.getNodeChildren,\n        onEnter: (node, indexPath) => {\n          if (this.isSameNode(node, rootNode)) return;\n          if (opts.skip?.({ value: this.getNodeValue(node), node, indexPath })) return \"skip\";\n          if (indexPath.length > 0 && !this.getNodeDisabled(node)) {\n            lastChild = node;\n          }\n        }\n      });\n      return lastChild;\n    });\n    __publicField(this, \"at\", (indexPath) => {\n      return access(this.rootNode, indexPath, {\n        getChildren: this.getNodeChildren\n      });\n    });\n    __publicField(this, \"findNode\", (value, rootNode = this.rootNode) => {\n      return find(rootNode, {\n        getChildren: this.getNodeChildren,\n        predicate: (node) => this.getNodeValue(node) === value\n      });\n    });\n    __publicField(this, \"findNodes\", (values, rootNode = this.rootNode) => {\n      const v = new Set(values.filter((v2) => v2 != null));\n      return findAll(rootNode, {\n        getChildren: this.getNodeChildren,\n        predicate: (node) => v.has(this.getNodeValue(node))\n      });\n    });\n    __publicField(this, \"sort\", (values) => {\n      return values.reduce((acc, value) => {\n        const indexPath = this.getIndexPath(value);\n        if (indexPath) acc.push({ value, indexPath });\n        return acc;\n      }, []).sort((a, b) => compareIndexPaths(a.indexPath, b.indexPath)).map(({ value }) => value);\n    });\n    __publicField(this, \"getValue\", (indexPath) => {\n      const node = this.at(indexPath);\n      return node ? this.getNodeValue(node) : void 0;\n    });\n    __publicField(this, \"getValuePath\", (indexPath) => {\n      if (!indexPath) return [];\n      const valuePath = [];\n      let currentPath = [...indexPath];\n      while (currentPath.length > 0) {\n        const node = this.at(currentPath);\n        if (node) valuePath.unshift(this.getNodeValue(node));\n        currentPath.pop();\n      }\n      return valuePath;\n    });\n    __publicField(this, \"getDepth\", (value) => {\n      const indexPath = findIndexPath(this.rootNode, {\n        getChildren: this.getNodeChildren,\n        predicate: (node) => this.getNodeValue(node) === value\n      });\n      return indexPath?.length ?? 0;\n    });\n    __publicField(this, \"isSameNode\", (node, other) => {\n      return this.getNodeValue(node) === this.getNodeValue(other);\n    });\n    __publicField(this, \"isRootNode\", (node) => {\n      return this.isSameNode(node, this.rootNode);\n    });\n    __publicField(this, \"contains\", (parentIndexPath, valueIndexPath) => {\n      if (!parentIndexPath || !valueIndexPath) return false;\n      return valueIndexPath.slice(0, parentIndexPath.length).every((_, i) => parentIndexPath[i] === valueIndexPath[i]);\n    });\n    __publicField(this, \"getNextNode\", (value, opts = {}) => {\n      let found = false;\n      let nextNode;\n      visit(this.rootNode, {\n        getChildren: this.getNodeChildren,\n        onEnter: (node, indexPath) => {\n          if (this.isRootNode(node)) return;\n          const nodeValue = this.getNodeValue(node);\n          if (opts.skip?.({ value: nodeValue, node, indexPath })) {\n            if (nodeValue === value) {\n              found = true;\n            }\n            return \"skip\";\n          }\n          if (found && !this.getNodeDisabled(node)) {\n            nextNode = node;\n            return \"stop\";\n          }\n          if (nodeValue === value) {\n            found = true;\n          }\n        }\n      });\n      return nextNode;\n    });\n    __publicField(this, \"getPreviousNode\", (value, opts = {}) => {\n      let previousNode;\n      let found = false;\n      visit(this.rootNode, {\n        getChildren: this.getNodeChildren,\n        onEnter: (node, indexPath) => {\n          if (this.isRootNode(node)) return;\n          const nodeValue = this.getNodeValue(node);\n          if (opts.skip?.({ value: nodeValue, node, indexPath })) {\n            return \"skip\";\n          }\n          if (nodeValue === value) {\n            found = true;\n            return \"stop\";\n          }\n          if (!this.getNodeDisabled(node)) {\n            previousNode = node;\n          }\n        }\n      });\n      return found ? previousNode : void 0;\n    });\n    __publicField(this, \"getParentNodes\", (valueOrIndexPath) => {\n      const indexPath = this.resolveIndexPath(valueOrIndexPath)?.slice();\n      if (!indexPath) return [];\n      const result = [];\n      while (indexPath.length > 0) {\n        indexPath.pop();\n        const parentNode = this.at(indexPath);\n        if (parentNode && !this.isRootNode(parentNode)) {\n          result.unshift(parentNode);\n        }\n      }\n      return result;\n    });\n    __publicField(this, \"getDescendantNodes\", (valueOrIndexPath, options) => {\n      const parentNode = this.resolveNode(valueOrIndexPath);\n      if (!parentNode) return [];\n      const result = [];\n      visit(parentNode, {\n        getChildren: this.getNodeChildren,\n        onEnter: (node, nodeIndexPath) => {\n          if (nodeIndexPath.length === 0) return;\n          if (!options?.withBranch && this.isBranchNode(node)) return;\n          result.push(node);\n        }\n      });\n      return result;\n    });\n    __publicField(this, \"getDescendantValues\", (valueOrIndexPath, options) => {\n      const children = this.getDescendantNodes(valueOrIndexPath, options);\n      return children.map((child) => this.getNodeValue(child));\n    });\n    __publicField(this, \"getParentIndexPath\", (indexPath) => {\n      return indexPath.slice(0, -1);\n    });\n    __publicField(this, \"getParentNode\", (valueOrIndexPath) => {\n      const indexPath = this.resolveIndexPath(valueOrIndexPath);\n      return indexPath ? this.at(this.getParentIndexPath(indexPath)) : void 0;\n    });\n    __publicField(this, \"visit\", (opts) => {\n      const { skip, ...rest } = opts;\n      visit(this.rootNode, {\n        ...rest,\n        getChildren: this.getNodeChildren,\n        onEnter: (node, indexPath) => {\n          if (this.isRootNode(node)) return;\n          if (skip?.({ value: this.getNodeValue(node), node, indexPath })) return \"skip\";\n          return rest.onEnter?.(node, indexPath);\n        }\n      });\n    });\n    __publicField(this, \"getPreviousSibling\", (indexPath) => {\n      const parentNode = this.getParentNode(indexPath);\n      if (!parentNode) return;\n      const siblings = this.getNodeChildren(parentNode);\n      let idx = indexPath[indexPath.length - 1];\n      while (--idx >= 0) {\n        const sibling = siblings[idx];\n        if (!this.getNodeDisabled(sibling)) return sibling;\n      }\n      return;\n    });\n    __publicField(this, \"getNextSibling\", (indexPath) => {\n      const parentNode = this.getParentNode(indexPath);\n      if (!parentNode) return;\n      const siblings = this.getNodeChildren(parentNode);\n      let idx = indexPath[indexPath.length - 1];\n      while (++idx < siblings.length) {\n        const sibling = siblings[idx];\n        if (!this.getNodeDisabled(sibling)) return sibling;\n      }\n      return;\n    });\n    __publicField(this, \"getSiblingNodes\", (indexPath) => {\n      const parentNode = this.getParentNode(indexPath);\n      return parentNode ? this.getNodeChildren(parentNode) : [];\n    });\n    __publicField(this, \"getValues\", (rootNode = this.rootNode) => {\n      const values = flatMap(rootNode, {\n        getChildren: this.getNodeChildren,\n        transform: (node) => [this.getNodeValue(node)]\n      });\n      return values.slice(1);\n    });\n    __publicField(this, \"isValidDepth\", (indexPath, depth) => {\n      if (depth == null) return true;\n      if (typeof depth === \"function\") return depth(indexPath.length);\n      return indexPath.length === depth;\n    });\n    __publicField(this, \"isBranchNode\", (node) => {\n      return this.getNodeChildren(node).length > 0 || this.getNodeChildrenCount(node) != null;\n    });\n    __publicField(this, \"getBranchValues\", (rootNode = this.rootNode, opts = {}) => {\n      let values = [];\n      visit(rootNode, {\n        getChildren: this.getNodeChildren,\n        onEnter: (node, indexPath) => {\n          if (indexPath.length === 0) return;\n          const nodeValue = this.getNodeValue(node);\n          if (opts.skip?.({ value: nodeValue, node, indexPath })) return \"skip\";\n          if (this.isBranchNode(node) && this.isValidDepth(indexPath, opts.depth)) {\n            values.push(this.getNodeValue(node));\n          }\n        }\n      });\n      return values;\n    });\n    __publicField(this, \"flatten\", (rootNode = this.rootNode) => {\n      return flatten(rootNode, { getChildren: this.getNodeChildren });\n    });\n    __publicField(this, \"_create\", (node, children) => {\n      if (this.getNodeChildren(node).length > 0 || children.length > 0) {\n        return { ...node, children };\n      }\n      return { ...node };\n    });\n    __publicField(this, \"_insert\", (rootNode, indexPath, nodes) => {\n      return this.copy(\n        insert(rootNode, { at: indexPath, nodes, getChildren: this.getNodeChildren, create: this._create })\n      );\n    });\n    __publicField(this, \"copy\", (rootNode) => {\n      return new _TreeCollection({ ...this.options, rootNode });\n    });\n    __publicField(this, \"_replace\", (rootNode, indexPath, node) => {\n      return this.copy(\n        replace(rootNode, { at: indexPath, node, getChildren: this.getNodeChildren, create: this._create })\n      );\n    });\n    __publicField(this, \"_move\", (rootNode, indexPaths, to) => {\n      return this.copy(move(rootNode, { indexPaths, to, getChildren: this.getNodeChildren, create: this._create }));\n    });\n    __publicField(this, \"_remove\", (rootNode, indexPaths) => {\n      return this.copy(remove(rootNode, { indexPaths, getChildren: this.getNodeChildren, create: this._create }));\n    });\n    __publicField(this, \"replace\", (indexPath, node) => {\n      return this._replace(this.rootNode, indexPath, node);\n    });\n    __publicField(this, \"remove\", (indexPaths) => {\n      return this._remove(this.rootNode, indexPaths);\n    });\n    __publicField(this, \"insertBefore\", (indexPath, nodes) => {\n      const parentNode = this.getParentNode(indexPath);\n      return parentNode ? this._insert(this.rootNode, indexPath, nodes) : void 0;\n    });\n    __publicField(this, \"insertAfter\", (indexPath, nodes) => {\n      const parentNode = this.getParentNode(indexPath);\n      if (!parentNode) return;\n      const nextIndex = [...indexPath.slice(0, -1), indexPath[indexPath.length - 1] + 1];\n      return this._insert(this.rootNode, nextIndex, nodes);\n    });\n    __publicField(this, \"move\", (fromIndexPaths, toIndexPath) => {\n      return this._move(this.rootNode, fromIndexPaths, toIndexPath);\n    });\n    __publicField(this, \"filter\", (predicate) => {\n      const filteredRoot = filter(this.rootNode, {\n        predicate,\n        getChildren: this.getNodeChildren,\n        create: this._create\n      });\n      return this.copy(filteredRoot);\n    });\n    __publicField(this, \"toJSON\", () => {\n      return this.getValues(this.rootNode);\n    });\n    this.rootNode = options.rootNode;\n  }\n  getIndexPath(valueOrValuePath) {\n    if (Array.isArray(valueOrValuePath)) {\n      if (valueOrValuePath.length === 0) return [];\n      const indexPath = [];\n      let currentChildren = this.getNodeChildren(this.rootNode);\n      for (let i = 0; i < valueOrValuePath.length; i++) {\n        const currentValue = valueOrValuePath[i];\n        const matchingChildIndex = currentChildren.findIndex((child) => this.getNodeValue(child) === currentValue);\n        if (matchingChildIndex === -1) break;\n        indexPath.push(matchingChildIndex);\n        if (i < valueOrValuePath.length - 1) {\n          const currentNode = currentChildren[matchingChildIndex];\n          currentChildren = this.getNodeChildren(currentNode);\n        }\n      }\n      return indexPath;\n    } else {\n      return findIndexPath(this.rootNode, {\n        getChildren: this.getNodeChildren,\n        predicate: (node) => this.getNodeValue(node) === valueOrValuePath\n      });\n    }\n  }\n};\nfunction flattenedToTree(nodes, options = fallbackMethods) {\n  if (nodes.length === 0) {\n    throw new Error(\"[zag-js/tree] Cannot create tree from empty flattened array\");\n  }\n  const rootFlatNode = nodes.find((node) => node._parent === void 0);\n  if (!rootFlatNode) {\n    throw new Error(\"[zag-js/tree] No root node found in flattened data\");\n  }\n  const nodeMap = /* @__PURE__ */ new Map();\n  nodes.forEach((node) => {\n    nodeMap.set(node._index, node);\n  });\n  const buildNode = (idx) => {\n    const flatNode = nodeMap.get(idx);\n    if (!flatNode) return {};\n    const { _children, _parent, _index, ...cleanNode } = flatNode;\n    const children = [];\n    _children?.forEach((childIndex) => {\n      children.push(buildNode(childIndex));\n    });\n    return {\n      ...cleanNode,\n      ...children.length > 0 && { children }\n    };\n  };\n  const rootNode = buildNode(rootFlatNode._index);\n  return new TreeCollection({ ...options, rootNode });\n}\nfunction filePathToTree(paths) {\n  const rootNode = {\n    label: \"\",\n    value: \"ROOT\",\n    children: []\n  };\n  paths.forEach((path) => {\n    const parts = path.split(\"/\");\n    let currentNode = rootNode;\n    parts.forEach((part, index) => {\n      let childNode = currentNode.children?.find((child) => child.label === part);\n      if (!childNode) {\n        childNode = {\n          value: parts.slice(0, index + 1).join(\"/\"),\n          label: part\n        };\n        currentNode.children || (currentNode.children = []);\n        currentNode.children.push(childNode);\n      }\n      currentNode = childNode;\n    });\n  });\n  return new TreeCollection({ rootNode });\n}\nvar fallbackMethods = {\n  nodeToValue(node) {\n    if (typeof node === \"string\") return node;\n    if (isObject(node) && hasProp(node, \"value\")) return node.value;\n    return \"\";\n  },\n  nodeToString(node) {\n    if (typeof node === \"string\") return node;\n    if (isObject(node) && hasProp(node, \"label\")) return node.label;\n    return fallbackMethods.nodeToValue(node);\n  },\n  isNodeDisabled(node) {\n    if (isObject(node) && hasProp(node, \"disabled\")) return !!node.disabled;\n    return false;\n  },\n  nodeToChildren(node) {\n    return node.children;\n  },\n  nodeToChildrenCount(node) {\n    if (isObject(node) && hasProp(node, \"childrenCount\")) return node.childrenCount;\n  }\n};\nexport {\n  TreeCollection,\n  filePathToTree,\n  flattenedToTree\n};\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.bun/@zag-js_collection@1.38.2/node_modules/@zag-js/collection/dist/tree-visit.js

@@ -0,0 +1,255 @@
+//#region ../../node_modules/.bun/@zag-js+collection@1.38.2/node_modules/@zag-js/collection/dist/tree-visit.mjs
+function e(e, t, n) {
+	for (let r = 0; r < t.length; r++) e = n.getChildren(e, t.slice(r + 1))[t[r]];
+	return e;
+}
+function t(e) {
+	let t = r(e), n = [], i = /* @__PURE__ */ new Set();
+	for (let e of t) {
+		let t = e.join();
+		i.has(t) || (i.add(t), n.push(e));
+	}
+	return n;
+}
+function n(e, t) {
+	for (let n = 0; n < Math.min(e.length, t.length); n++) {
+		if (e[n] < t[n]) return -1;
+		if (e[n] > t[n]) return 1;
+	}
+	return e.length - t.length;
+}
+function r(e) {
+	return e.sort(n);
+}
+function i(e, t) {
+	let n;
+	return T(e, {
+		...t,
+		onEnter: (e, r) => {
+			if (t.predicate(e, r)) return n = e, "stop";
+		}
+	}), n;
+}
+function a(e, t) {
+	let n = [];
+	return T(e, {
+		onEnter: (e, r) => {
+			t.predicate(e, r) && n.push(e);
+		},
+		getChildren: t.getChildren
+	}), n;
+}
+function o(e, t) {
+	let n;
+	return T(e, {
+		onEnter: (e, r) => {
+			if (t.predicate(e, r)) return n = [...r], "stop";
+		},
+		getChildren: t.getChildren
+	}), n;
+}
+function s(e, t) {
+	let n = t.initialResult;
+	return T(e, {
+		...t,
+		onEnter: (e, r) => {
+			n = t.nextResult(n, e, r);
+		}
+	}), n;
+}
+function c(e, t) {
+	return s(e, {
+		...t,
+		initialResult: [],
+		nextResult: (e, n, r) => (e.push(...t.transform(n, r)), e)
+	});
+}
+function l(e, t) {
+	let { predicate: n, create: r, getChildren: i } = t, a = (e, t) => {
+		let o = i(e, t), s = [];
+		o.forEach((e, n) => {
+			let r = a(e, [...t, n]);
+			r && s.push(r);
+		});
+		let c = t.length === 0, l = n(e, t), u = s.length > 0;
+		return c || l || u ? r(e, s, t) : null;
+	};
+	return a(e, []) || r(e, [], []);
+}
+function u(e, t) {
+	let n = [], r = 0, i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+	return T(e, {
+		getChildren: t.getChildren,
+		onEnter: (e, o) => {
+			i.has(e) || i.set(e, r++);
+			let s = t.getChildren(e, o);
+			s.forEach((t) => {
+				a.has(t) || a.set(t, e), i.has(t) || i.set(t, r++);
+			});
+			let c = s.length > 0 ? s.map((e) => i.get(e)) : void 0, l = a.get(e), u = l ? i.get(l) : void 0, d = i.get(e);
+			n.push({
+				...e,
+				_children: c,
+				_parent: u,
+				_index: d
+			});
+		}
+	}), n;
+}
+function d(e, t) {
+	return {
+		type: "insert",
+		index: e,
+		nodes: t
+	};
+}
+function f(e) {
+	return {
+		type: "remove",
+		indexes: e
+	};
+}
+function p() {
+	return { type: "replace" };
+}
+function m(e) {
+	return [e.slice(0, -1), e[e.length - 1]];
+}
+function h(e, t, n = /* @__PURE__ */ new Map()) {
+	let [r, i] = m(e);
+	for (let e = r.length - 1; e >= 0; e--) {
+		let t = r.slice(0, e).join();
+		switch (n.get(t)?.type) {
+			case "remove": continue;
+		}
+		n.set(t, p());
+	}
+	let a = n.get(r.join());
+	switch (a?.type) {
+		case "remove":
+			n.set(r.join(), {
+				type: "removeThenInsert",
+				removeIndexes: a.indexes,
+				insertIndex: i,
+				insertNodes: t
+			});
+			break;
+		default: n.set(r.join(), d(i, t));
+	}
+	return n;
+}
+function g(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		let e = t.slice(0, -1).join(), r = n.get(e) ?? [];
+		r.push(t[t.length - 1]), n.set(e, r.sort((e, t) => e - t));
+	}
+	for (let n of e) for (let e = n.length - 2; e >= 0; e--) {
+		let r = n.slice(0, e).join();
+		t.has(r) || t.set(r, p());
+	}
+	for (let [e, r] of n) t.set(e, f(r));
+	return t;
+}
+function _(e, t) {
+	let n = /* @__PURE__ */ new Map(), [r, i] = m(e);
+	for (let e = r.length - 1; e >= 0; e--) {
+		let t = r.slice(0, e).join();
+		n.set(t, p());
+	}
+	return n.set(r.join(), {
+		type: "removeThenInsert",
+		removeIndexes: [i],
+		insertIndex: i,
+		insertNodes: [t]
+	}), n;
+}
+function v(e, t, n) {
+	return b(e, {
+		...n,
+		getChildren: (e, r) => {
+			let i = r.join();
+			switch (t.get(i)?.type) {
+				case "replace":
+				case "remove":
+				case "removeThenInsert":
+				case "insert": return n.getChildren(e, r);
+				default: return [];
+			}
+		},
+		transform: (e, r, i) => {
+			let a = i.join(), o = t.get(a);
+			switch (o?.type) {
+				case "remove": return n.create(e, r.filter((e, t) => !o.indexes.includes(t)), i);
+				case "removeThenInsert":
+					let t = r.filter((e, t) => !o.removeIndexes.includes(t)), a = o.removeIndexes.reduce((e, t) => t < e ? e - 1 : e, o.insertIndex);
+					return n.create(e, y(t, a, 0, ...o.insertNodes), i);
+				case "insert": return n.create(e, y(r, o.index, 0, ...o.nodes), i);
+				case "replace": return n.create(e, r, i);
+				default: return e;
+			}
+		}
+	});
+}
+function y(e, t, n, ...r) {
+	return [
+		...e.slice(0, t),
+		...r,
+		...e.slice(t + n)
+	];
+}
+function b(e, t) {
+	let n = {};
+	return T(e, {
+		...t,
+		onLeave: (e, r) => {
+			let i = [0, ...r], a = i.join(), o = t.transform(e, n[a] ?? [], r), s = i.slice(0, -1).join(), c = n[s] ?? [];
+			c.push(o), n[s] = c;
+		}
+	}), n[""][0];
+}
+function x(e, t) {
+	let { nodes: n, at: r } = t;
+	if (r.length === 0) throw Error("Can't insert nodes at the root");
+	return v(e, h(r, n), t);
+}
+function S(e, t) {
+	return t.at.length === 0 ? t.node : v(e, _(t.at, t.node), t);
+}
+function C(e, t) {
+	if (t.indexPaths.length === 0) return e;
+	for (let e of t.indexPaths) if (e.length === 0) throw Error("Can't remove the root node");
+	return v(e, g(t.indexPaths), t);
+}
+function w(n, r) {
+	if (r.indexPaths.length === 0) return n;
+	for (let e of r.indexPaths) if (e.length === 0) throw Error("Can't move the root node");
+	if (r.to.length === 0) throw Error("Can't move nodes to the root");
+	let i = t(r.indexPaths), a = i.map((t) => e(n, t, r));
+	return v(n, h(r.to, a, g(i)), r);
+}
+function T(e, t) {
+	let { onEnter: n, onLeave: r, getChildren: i } = t, a = [], o = [{ node: e }], s = t.reuseIndexPath ? () => a : () => a.slice();
+	for (; o.length > 0;) {
+		let e = o[o.length - 1];
+		if (e.state === void 0) {
+			let t = n?.(e.node, s());
+			if (t === "stop") return;
+			e.state = t === "skip" ? -1 : 0;
+		}
+		let t = e.children || i(e.node, s());
+		if (e.children ||= t, e.state !== -1) {
+			if (e.state < t.length) {
+				let n = e.state;
+				a.push(n), o.push({ node: t[n] }), e.state = n + 1;
+				continue;
+			}
+			if (r?.(e.node, s()) === "stop") return;
+		}
+		a.pop(), o.pop();
+	}
+}
+//#endregion
+export { e as access, n as compareIndexPaths, l as filter, i as find, a as findAll, o as findIndexPath, c as flatMap, u as flatten, x as insert, w as move, C as remove, S as replace, T as visit };
+
+//# sourceMappingURL=tree-visit.js.map

package/dist/node_modules/.bun/@zag-js_collection@1.38.2/node_modules/@zag-js/collection/dist/tree-visit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-visit.js","names":[],"sources":["../../../../../../../../../../node_modules/.bun/@zag-js+collection@1.38.2/node_modules/@zag-js/collection/dist/tree-visit.mjs"],"sourcesContent":["import \"./chunk-QZ7TP4HQ.mjs\";\n\n// src/tree-visit.ts\nfunction access(node, indexPath, options) {\n  for (let i = 0; i < indexPath.length; i++) node = options.getChildren(node, indexPath.slice(i + 1))[indexPath[i]];\n  return node;\n}\nfunction accessPath(node, indexPath, options) {\n  const result = [node];\n  for (let i = 0; i < indexPath.length; i++) {\n    node = options.getChildren(node, indexPath.slice(i + 1))[indexPath[i]];\n    result.push(node);\n  }\n  return result;\n}\nfunction ancestorIndexPaths(indexPaths) {\n  const sortedPaths = sortIndexPaths(indexPaths);\n  const result = [];\n  const seen = /* @__PURE__ */ new Set();\n  for (const indexPath of sortedPaths) {\n    const key = indexPath.join();\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(indexPath);\n    }\n  }\n  return result;\n}\nfunction compareIndexPaths(a, b) {\n  for (let i = 0; i < Math.min(a.length, b.length); i++) {\n    if (a[i] < b[i]) return -1;\n    if (a[i] > b[i]) return 1;\n  }\n  return a.length - b.length;\n}\nfunction sortIndexPaths(indexPaths) {\n  return indexPaths.sort(compareIndexPaths);\n}\nfunction find(node, options) {\n  let found;\n  visit(node, {\n    ...options,\n    onEnter: (child, indexPath) => {\n      if (options.predicate(child, indexPath)) {\n        found = child;\n        return \"stop\";\n      }\n    }\n  });\n  return found;\n}\nfunction findAll(node, options) {\n  const found = [];\n  visit(node, {\n    onEnter: (child, indexPath) => {\n      if (options.predicate(child, indexPath)) found.push(child);\n    },\n    getChildren: options.getChildren\n  });\n  return found;\n}\nfunction findIndexPath(node, options) {\n  let found;\n  visit(node, {\n    onEnter: (child, indexPath) => {\n      if (options.predicate(child, indexPath)) {\n        found = [...indexPath];\n        return \"stop\";\n      }\n    },\n    getChildren: options.getChildren\n  });\n  return found;\n}\nfunction findAllIndexPaths(node, options) {\n  let found = [];\n  visit(node, {\n    onEnter: (child, indexPath) => {\n      if (options.predicate(child, indexPath)) found.push([...indexPath]);\n    },\n    getChildren: options.getChildren\n  });\n  return found;\n}\nfunction reduce(node, options) {\n  let result = options.initialResult;\n  visit(node, {\n    ...options,\n    onEnter: (child, indexPath) => {\n      result = options.nextResult(result, child, indexPath);\n    }\n  });\n  return result;\n}\nfunction flat(node, options) {\n  return reduce(node, {\n    ...options,\n    initialResult: [],\n    nextResult: (result, child) => {\n      result.push(child);\n      return result;\n    }\n  });\n}\nfunction flatMap(node, options) {\n  return reduce(node, {\n    ...options,\n    initialResult: [],\n    nextResult: (result, child, indexPath) => {\n      result.push(...options.transform(child, indexPath));\n      return result;\n    }\n  });\n}\nfunction filter(node, options) {\n  const { predicate, create, getChildren } = options;\n  const filterRecursive = (node2, indexPath) => {\n    const children = getChildren(node2, indexPath);\n    const filteredChildren = [];\n    children.forEach((child, index) => {\n      const childIndexPath = [...indexPath, index];\n      const filteredChild = filterRecursive(child, childIndexPath);\n      if (filteredChild) filteredChildren.push(filteredChild);\n    });\n    const isRoot = indexPath.length === 0;\n    const nodeMatches = predicate(node2, indexPath);\n    const hasFilteredChildren = filteredChildren.length > 0;\n    if (isRoot || nodeMatches || hasFilteredChildren) {\n      return create(node2, filteredChildren, indexPath);\n    }\n    return null;\n  };\n  return filterRecursive(node, []) || create(node, [], []);\n}\nfunction flatten(rootNode, options) {\n  const nodes = [];\n  let idx = 0;\n  const idxMap = /* @__PURE__ */ new Map();\n  const parentMap = /* @__PURE__ */ new Map();\n  visit(rootNode, {\n    getChildren: options.getChildren,\n    onEnter: (node, indexPath) => {\n      if (!idxMap.has(node)) {\n        idxMap.set(node, idx++);\n      }\n      const children = options.getChildren(node, indexPath);\n      children.forEach((child) => {\n        if (!parentMap.has(child)) {\n          parentMap.set(child, node);\n        }\n        if (!idxMap.has(child)) {\n          idxMap.set(child, idx++);\n        }\n      });\n      const _children = children.length > 0 ? children.map((child) => idxMap.get(child)) : void 0;\n      const parent = parentMap.get(node);\n      const _parent = parent ? idxMap.get(parent) : void 0;\n      const _index = idxMap.get(node);\n      nodes.push({ ...node, _children, _parent, _index });\n    }\n  });\n  return nodes;\n}\nfunction insertOperation(index, nodes) {\n  return { type: \"insert\", index, nodes };\n}\nfunction removeOperation(indexes) {\n  return { type: \"remove\", indexes };\n}\nfunction replaceOperation() {\n  return { type: \"replace\" };\n}\nfunction splitIndexPath(indexPath) {\n  return [indexPath.slice(0, -1), indexPath[indexPath.length - 1]];\n}\nfunction getInsertionOperations(indexPath, nodes, operations = /* @__PURE__ */ new Map()) {\n  const [parentIndexPath, index] = splitIndexPath(indexPath);\n  for (let i = parentIndexPath.length - 1; i >= 0; i--) {\n    const parentKey = parentIndexPath.slice(0, i).join();\n    switch (operations.get(parentKey)?.type) {\n      case \"remove\":\n        continue;\n    }\n    operations.set(parentKey, replaceOperation());\n  }\n  const operation = operations.get(parentIndexPath.join());\n  switch (operation?.type) {\n    case \"remove\":\n      operations.set(parentIndexPath.join(), {\n        type: \"removeThenInsert\",\n        removeIndexes: operation.indexes,\n        insertIndex: index,\n        insertNodes: nodes\n      });\n      break;\n    default:\n      operations.set(parentIndexPath.join(), insertOperation(index, nodes));\n  }\n  return operations;\n}\nfunction getRemovalOperations(indexPaths) {\n  const operations = /* @__PURE__ */ new Map();\n  const indexesToRemove = /* @__PURE__ */ new Map();\n  for (const indexPath of indexPaths) {\n    const parentKey = indexPath.slice(0, -1).join();\n    const value = indexesToRemove.get(parentKey) ?? [];\n    value.push(indexPath[indexPath.length - 1]);\n    indexesToRemove.set(\n      parentKey,\n      value.sort((a, b) => a - b)\n    );\n  }\n  for (const indexPath of indexPaths) {\n    for (let i = indexPath.length - 2; i >= 0; i--) {\n      const parentKey = indexPath.slice(0, i).join();\n      if (!operations.has(parentKey)) {\n        operations.set(parentKey, replaceOperation());\n      }\n    }\n  }\n  for (const [parentKey, indexes] of indexesToRemove) {\n    operations.set(parentKey, removeOperation(indexes));\n  }\n  return operations;\n}\nfunction getReplaceOperations(indexPath, node) {\n  const operations = /* @__PURE__ */ new Map();\n  const [parentIndexPath, index] = splitIndexPath(indexPath);\n  for (let i = parentIndexPath.length - 1; i >= 0; i--) {\n    const parentKey = parentIndexPath.slice(0, i).join();\n    operations.set(parentKey, replaceOperation());\n  }\n  operations.set(parentIndexPath.join(), {\n    type: \"removeThenInsert\",\n    removeIndexes: [index],\n    insertIndex: index,\n    insertNodes: [node]\n  });\n  return operations;\n}\nfunction mutate(node, operations, options) {\n  return map(node, {\n    ...options,\n    getChildren: (node2, indexPath) => {\n      const key = indexPath.join();\n      const operation = operations.get(key);\n      switch (operation?.type) {\n        case \"replace\":\n        case \"remove\":\n        case \"removeThenInsert\":\n        case \"insert\":\n          return options.getChildren(node2, indexPath);\n        default:\n          return [];\n      }\n    },\n    transform: (node2, children, indexPath) => {\n      const key = indexPath.join();\n      const operation = operations.get(key);\n      switch (operation?.type) {\n        case \"remove\":\n          return options.create(\n            node2,\n            children.filter((_, index) => !operation.indexes.includes(index)),\n            indexPath\n          );\n        case \"removeThenInsert\":\n          const updatedChildren = children.filter((_, index) => !operation.removeIndexes.includes(index));\n          const adjustedIndex = operation.removeIndexes.reduce(\n            (index, removedIndex) => removedIndex < index ? index - 1 : index,\n            operation.insertIndex\n          );\n          return options.create(node2, splice(updatedChildren, adjustedIndex, 0, ...operation.insertNodes), indexPath);\n        case \"insert\":\n          return options.create(node2, splice(children, operation.index, 0, ...operation.nodes), indexPath);\n        case \"replace\":\n          return options.create(node2, children, indexPath);\n        default:\n          return node2;\n      }\n    }\n  });\n}\nfunction splice(array, start, deleteCount, ...items) {\n  return [...array.slice(0, start), ...items, ...array.slice(start + deleteCount)];\n}\nfunction map(node, options) {\n  const childrenMap = {};\n  visit(node, {\n    ...options,\n    onLeave: (child, indexPath) => {\n      const keyIndexPath = [0, ...indexPath];\n      const key = keyIndexPath.join();\n      const transformed = options.transform(child, childrenMap[key] ?? [], indexPath);\n      const parentKey = keyIndexPath.slice(0, -1).join();\n      const parentChildren = childrenMap[parentKey] ?? [];\n      parentChildren.push(transformed);\n      childrenMap[parentKey] = parentChildren;\n    }\n  });\n  return childrenMap[\"\"][0];\n}\nfunction insert(node, options) {\n  const { nodes, at } = options;\n  if (at.length === 0) throw new Error(`Can't insert nodes at the root`);\n  const state = getInsertionOperations(at, nodes);\n  return mutate(node, state, options);\n}\nfunction replace(node, options) {\n  if (options.at.length === 0) return options.node;\n  const operations = getReplaceOperations(options.at, options.node);\n  return mutate(node, operations, options);\n}\nfunction remove(node, options) {\n  if (options.indexPaths.length === 0) return node;\n  for (const indexPath of options.indexPaths) {\n    if (indexPath.length === 0) throw new Error(`Can't remove the root node`);\n  }\n  const operations = getRemovalOperations(options.indexPaths);\n  return mutate(node, operations, options);\n}\nfunction move(node, options) {\n  if (options.indexPaths.length === 0) return node;\n  for (const indexPath of options.indexPaths) {\n    if (indexPath.length === 0) throw new Error(`Can't move the root node`);\n  }\n  if (options.to.length === 0) throw new Error(`Can't move nodes to the root`);\n  const _ancestorIndexPaths = ancestorIndexPaths(options.indexPaths);\n  const nodesToInsert = _ancestorIndexPaths.map((indexPath) => access(node, indexPath, options));\n  const operations = getInsertionOperations(options.to, nodesToInsert, getRemovalOperations(_ancestorIndexPaths));\n  return mutate(node, operations, options);\n}\nfunction visit(node, options) {\n  const { onEnter, onLeave, getChildren } = options;\n  let indexPath = [];\n  let stack = [{ node }];\n  const getIndexPath = options.reuseIndexPath ? () => indexPath : () => indexPath.slice();\n  while (stack.length > 0) {\n    let wrapper = stack[stack.length - 1];\n    if (wrapper.state === void 0) {\n      const enterResult = onEnter?.(wrapper.node, getIndexPath());\n      if (enterResult === \"stop\") return;\n      wrapper.state = enterResult === \"skip\" ? -1 : 0;\n    }\n    const children = wrapper.children || getChildren(wrapper.node, getIndexPath());\n    wrapper.children || (wrapper.children = children);\n    if (wrapper.state !== -1) {\n      if (wrapper.state < children.length) {\n        let currentIndex = wrapper.state;\n        indexPath.push(currentIndex);\n        stack.push({ node: children[currentIndex] });\n        wrapper.state = currentIndex + 1;\n        continue;\n      }\n      const leaveResult = onLeave?.(wrapper.node, getIndexPath());\n      if (leaveResult === \"stop\") return;\n    }\n    indexPath.pop();\n    stack.pop();\n  }\n}\nexport {\n  access,\n  accessPath,\n  ancestorIndexPaths,\n  compareIndexPaths,\n  filter,\n  find,\n  findAll,\n  findAllIndexPaths,\n  findIndexPath,\n  flat,\n  flatMap,\n  flatten,\n  insert,\n  map,\n  move,\n  reduce,\n  remove,\n  replace,\n  sortIndexPaths,\n  visit\n};\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.bun/@zag-js_combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.anatomy.js

@@ -0,0 +1,7 @@
+import { createAnatomy as e } from "../../../../../@zag-js_anatomy@1.38.2/node_modules/@zag-js/anatomy/dist/create-anatomy.js";
+//#region ../../node_modules/.bun/@zag-js+combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.anatomy.mjs
+var t = e("combobox").parts("root", "clearTrigger", "content", "control", "input", "item", "itemGroup", "itemGroupLabel", "itemIndicator", "itemText", "label", "list", "positioner", "trigger"), n = t.build();
+//#endregion
+export { t as anatomy, n as parts };
+
+//# sourceMappingURL=combobox.anatomy.js.map

package/dist/node_modules/.bun/@zag-js_combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.anatomy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"combobox.anatomy.js","names":[],"sources":["../../../../../../../../../../node_modules/.bun/@zag-js+combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.anatomy.mjs"],"sourcesContent":["// src/combobox.anatomy.ts\nimport { createAnatomy } from \"@zag-js/anatomy\";\nvar anatomy = createAnatomy(\"combobox\").parts(\n  \"root\",\n  \"clearTrigger\",\n  \"content\",\n  \"control\",\n  \"input\",\n  \"item\",\n  \"itemGroup\",\n  \"itemGroupLabel\",\n  \"itemIndicator\",\n  \"itemText\",\n  \"label\",\n  \"list\",\n  \"positioner\",\n  \"trigger\"\n);\nvar parts = anatomy.build();\nexport {\n  anatomy,\n  parts\n};\n"],"x_google_ignoreList":[0],"mappings":";;AAEA,IAAI,IAAU,EAAc,WAAW,CAAC,MACtC,QACA,gBACA,WACA,WACA,SACA,QACA,aACA,kBACA,iBACA,YACA,SACA,QACA,cACA,UACD,EACG,IAAQ,EAAQ,OAAO"}

package/dist/node_modules/.bun/@zag-js_combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.collection.js

@@ -0,0 +1,8 @@
+import { ListCollection as e } from "../../../../../@zag-js_collection@1.38.2/node_modules/@zag-js/collection/dist/list-collection.js";
+//#region ../../node_modules/.bun/@zag-js+combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.collection.mjs
+var t = (t) => new e(t);
+t.empty = () => new e({ items: [] });
+//#endregion
+export { t as collection };
+
+//# sourceMappingURL=combobox.collection.js.map

package/dist/node_modules/.bun/@zag-js_combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"combobox.collection.js","names":[],"sources":["../../../../../../../../../../node_modules/.bun/@zag-js+combobox@1.38.2/node_modules/@zag-js/combobox/dist/combobox.collection.mjs"],"sourcesContent":["// src/combobox.collection.ts\nimport { ListCollection } from \"@zag-js/collection\";\nvar collection = (options) => {\n  return new ListCollection(options);\n};\ncollection.empty = () => {\n  return new ListCollection({ items: [] });\n};\nexport {\n  collection\n};\n"],"x_google_ignoreList":[0],"mappings":";;AAEA,IAAI,KAAc,MACT,IAAI,EAAe,EAAQ;AAEpC,EAAW,cACF,IAAI,EAAe,EAAE,OAAO,EAAE,EAAE,CAAC"}