@manafishrov/ui 1.5.2 → 1.5.4

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

@@ -0,0 +1,272 @@
+import { isEqual as e } from "../../../../../@zag-js_utils@1.40.0/node_modules/@zag-js/utils/dist/equal.js";
+import { hasProp as t, isObject as n } from "../../../../../@zag-js_utils@1.40.0/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.40.0/node_modules/@zag-js/collection/dist/tree-collection.mjs
+var _ = class t {
+	constructor(n) {
+		r(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.40.0/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.40.0/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    __publicField(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.40.0/node_modules/@zag-js/collection/dist/tree-visit.js

@@ -0,0 +1,255 @@
+//#region ../../node_modules/.bun/@zag-js+collection@1.40.0/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.40.0/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.40.0/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.40.0/node_modules/@zag-js/combobox/dist/combobox.anatomy.js

@@ -0,0 +1,7 @@
+import { createAnatomy as e } from "../../../../../@zag-js_anatomy@1.40.0/node_modules/@zag-js/anatomy/dist/create-anatomy.js";
+//#region ../../node_modules/.bun/@zag-js+combobox@1.40.0/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.40.0/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.40.0/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,UAAU,EAAE,MACtC,QACA,gBACA,WACA,WACA,SACA,QACA,aACA,kBACA,iBACA,YACA,SACA,QACA,cACA,SACF,GACI,IAAQ,EAAQ,MAAM"}

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

@@ -0,0 +1,8 @@
+import { ListCollection as e } from "../../../../../@zag-js_collection@1.40.0/node_modules/@zag-js/collection/dist/list-collection.js";
+//#region ../../node_modules/.bun/@zag-js+combobox@1.40.0/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.40.0/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.40.0/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,CAAO;AAEnC,EAAW,cACF,IAAI,EAAe,EAAE,OAAO,CAAC,EAAE,CAAC"}