@noya-app/noya-file-explorer 0.0.2

package/dist/index.mjs

@@ -0,0 +1,1857 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/tree-visit/lib/access.js
+var require_access = __commonJS({
+  "../../node_modules/tree-visit/lib/access.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.accessPath = exports.access = void 0;
+    function access(node, indexPath, options) {
+      if (options.includeTraversalContext) {
+        const accessed = accessPath(node, indexPath, options);
+        return accessed[accessed.length - 1];
+      }
+      let path4 = indexPath.slice();
+      while (path4.length > 0) {
+        let index = path4.shift();
+        node = options.getChildren(node, path4)[index];
+      }
+      return node;
+    }
+    exports.access = access;
+    function accessPath(node, indexPath, options) {
+      let path4 = indexPath.slice();
+      let result = [node];
+      while (path4.length > 0) {
+        let index = path4.shift();
+        const context = options.includeTraversalContext ? {
+          getRoot: () => result[0],
+          getParent: () => result[result.length - 2],
+          getAncestors: () => result.slice(0, -1)
+        } : void 0;
+        node = options.getChildren(node, path4, context)[index];
+        result.push(node);
+      }
+      return result;
+    }
+    exports.accessPath = accessPath;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/sort.js
+var require_sort = __commonJS({
+  "../../node_modules/tree-visit/lib/sort.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sortPaths = exports.comparePathsByComponent = void 0;
+    function comparePathsByComponent(a, b) {
+      for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        if (a[i] < b[i])
+          return -1;
+        if (a[i] > b[i])
+          return 1;
+      }
+      return a.length - b.length;
+    }
+    exports.comparePathsByComponent = comparePathsByComponent;
+    function sortPaths(indexPaths) {
+      return [...indexPaths].sort(comparePathsByComponent);
+    }
+    exports.sortPaths = sortPaths;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/ancestors.js
+var require_ancestors = __commonJS({
+  "../../node_modules/tree-visit/lib/ancestors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ancestorPaths = void 0;
+    var sort_1 = require_sort();
+    function ancestorPaths2(paths, options) {
+      var _a;
+      const result = /* @__PURE__ */ new Map();
+      const compare = (_a = options === null || options === void 0 ? void 0 : options.compare) !== null && _a !== void 0 ? _a : sort_1.comparePathsByComponent;
+      const sortedIndexPaths = paths.sort(compare);
+      for (const indexPath of sortedIndexPaths) {
+        const foundParent = indexPath.some((_, index) => {
+          const parentKey = indexPath.slice(0, index).join();
+          return result.has(parentKey);
+        });
+        if (foundParent)
+          continue;
+        result.set(indexPath.join(), indexPath);
+      }
+      return Array.from(result.values());
+    }
+    exports.ancestorPaths = ancestorPaths2;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/diagram/boxDiagram.js
+var require_boxDiagram = __commonJS({
+  "../../node_modules/tree-visit/lib/diagram/boxDiagram.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.boxDiagram = void 0;
+    var BoxDrawing;
+    (function(BoxDrawing2) {
+      BoxDrawing2["TopLeft"] = "\u250C";
+      BoxDrawing2["TopRight"] = "\u2510";
+      BoxDrawing2["BottomLeft"] = "\u2514";
+      BoxDrawing2["BottomRight"] = "\u2518";
+      BoxDrawing2["Horizontal"] = "\u2500";
+      BoxDrawing2["Vertical"] = "\u2502";
+      BoxDrawing2["BottomConnectorDown"] = "\u252C";
+      BoxDrawing2["BottomConnectorUp"] = "\u2534";
+      BoxDrawing2["TopConnectorUp"] = "\u2534";
+    })(BoxDrawing || (BoxDrawing = {}));
+    function wrapLabelInBox(label) {
+      const lines = label.split("\n");
+      const length = Math.max(...lines.map((line) => line.length));
+      const horizontalMargin = 1;
+      const width = length + horizontalMargin * 2 + 2;
+      const height = 2 + lines.length;
+      const diagram = [
+        [
+          BoxDrawing.TopLeft,
+          BoxDrawing.Horizontal.repeat(length + horizontalMargin * 2),
+          BoxDrawing.TopRight
+        ],
+        ...lines.map((line) => [
+          BoxDrawing.Vertical,
+          " ".repeat(horizontalMargin),
+          line + (line.length < length ? " ".repeat(length - line.length) : ""),
+          " ".repeat(horizontalMargin),
+          BoxDrawing.Vertical
+        ]),
+        [
+          BoxDrawing.BottomLeft,
+          BoxDrawing.Horizontal.repeat(length + horizontalMargin * 2),
+          BoxDrawing.BottomRight
+        ]
+      ];
+      return {
+        width,
+        height,
+        contents: diagram.map((parts) => parts.join(""))
+      };
+    }
+    function mergeBoxesHorizontal(boxes) {
+      const horizontalMargin = 1;
+      if (boxes.length === 0) {
+        throw new Error("Can't merge empty array of boxes");
+      }
+      return boxes.slice(1).reduce((result, box) => {
+        const height = Math.max(result.height, box.height);
+        const width = result.width + horizontalMargin + box.width;
+        const contents = [];
+        for (let i = 0; i < height; i++) {
+          contents.push((result.contents[i] || " ".repeat(result.width)) + " ".repeat(horizontalMargin) + (box.contents[i] || " ".repeat(box.width)));
+        }
+        return { height, width, contents: centerBlock(contents, width) };
+      }, boxes[0]);
+    }
+    function mergeBoxesVertical(boxes) {
+      const verticalMargin = 1;
+      if (boxes.length === 0) {
+        throw new Error("Can't merge empty array of boxes");
+      }
+      const width = Math.max(...boxes.map((box) => box.width));
+      return boxes.slice(1).reduce((result, box) => {
+        const height = result.height + verticalMargin + box.height;
+        const contents = [];
+        for (let i = 0; i < height; i++) {
+          if (i < result.height) {
+            contents.push(result.contents[i]);
+          } else if (i === result.height) {
+            contents.push(" ".repeat(width));
+          } else {
+            contents.push(box.contents[i - result.height - 1]);
+          }
+        }
+        return { height, width, contents: centerBlock(contents, width) };
+      }, boxes[0]);
+    }
+    function nodeDiagram(node, indexPath, options) {
+      const label = options.getLabel(node, indexPath);
+      const box = wrapLabelInBox(label);
+      const children = options.getChildren(node, indexPath);
+      if (children.length === 0)
+        return box;
+      const childBoxes = children.map((child, index) => {
+        const childBox = nodeDiagram(child, [...indexPath, index], options);
+        childBox.contents[0] = insertSubstring(childBox.contents[0], centerIndex(childBox.contents[0].length), BoxDrawing.TopConnectorUp);
+        return childBox;
+      });
+      const result = mergeBoxesVertical([box, mergeBoxesHorizontal(childBoxes)]);
+      const contents = result.contents;
+      const mid = centerIndex(result.width);
+      contents[box.height - 1] = insertSubstring(contents[box.height - 1], mid, BoxDrawing.BottomConnectorDown);
+      let min = contents[box.height + 1].indexOf(BoxDrawing.TopConnectorUp);
+      let max = contents[box.height + 1].lastIndexOf(BoxDrawing.TopConnectorUp);
+      for (let i = min; i <= max; i++) {
+        let character;
+        if (i === mid) {
+          character = childBoxes.length > 1 ? BoxDrawing.BottomConnectorUp : BoxDrawing.Vertical;
+        } else if (i === min) {
+          character = BoxDrawing.TopLeft;
+        } else if (i === max) {
+          character = BoxDrawing.TopRight;
+        } else {
+          character = BoxDrawing.Horizontal;
+        }
+        result.contents[box.height] = insertSubstring(result.contents[box.height], i, character);
+      }
+      return result;
+    }
+    function boxDiagram(node, options) {
+      return nodeDiagram(node, [], options).contents.join("\n");
+    }
+    exports.boxDiagram = boxDiagram;
+    function centerIndex(width) {
+      return Math.floor(width / 2);
+    }
+    function centerLine(line, width) {
+      const remainder = width - line.length;
+      if (remainder <= 0)
+        return line;
+      const prefixLength = centerIndex(remainder);
+      const suffixLength = centerIndex(remainder);
+      const result = " ".repeat(prefixLength) + line + " ".repeat(suffixLength);
+      return prefixLength + suffixLength + result.length < width ? result + " " : result;
+    }
+    function centerBlock(lines, width) {
+      return lines.map((line) => centerLine(line, width));
+    }
+    function insertSubstring(string, index, substring) {
+      if (index > string.length - 1)
+        return string;
+      return string.substring(0, index) + substring + string.substring(index + 1);
+    }
+  }
+});
+
+// ../../node_modules/tree-visit/lib/diagram/directoryDiagram.js
+var require_directoryDiagram = __commonJS({
+  "../../node_modules/tree-visit/lib/diagram/directoryDiagram.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.prefixBlock = exports.isMultiline = exports.directoryDiagram = void 0;
+    var LinePrefix;
+    (function(LinePrefix2) {
+      LinePrefix2["Child"] = "\u251C\u2500\u2500 ";
+      LinePrefix2["LastChild"] = "\u2514\u2500\u2500 ";
+      LinePrefix2["NestedChild"] = "\u2502   ";
+      LinePrefix2["LastNestedChild"] = "    ";
+    })(LinePrefix || (LinePrefix = {}));
+    function nodeDiagram(node, indexPath, options) {
+      const label = options.getLabel(node, indexPath);
+      const depth = indexPath.length;
+      let rootLine = { label, depth, prefix: "", multilinePrefix: "" };
+      const children = options.getChildren(node, indexPath);
+      if (children.length === 0)
+        return [rootLine];
+      if (options.flattenSingleChildNodes && children.length === 1 && !isMultiline(label)) {
+        const [line] = nodeDiagram(children[0], [...indexPath, 0], options);
+        const hideRoot = indexPath.length === 0 && label === "";
+        rootLine.label = hideRoot ? `/ ${line.label}` : `${rootLine.label} / ${line.label}`;
+        return [rootLine];
+      }
+      const nestedLines = children.flatMap((file, index, array) => {
+        const childIsLast = index === array.length - 1;
+        const childLines = nodeDiagram(file, [...indexPath, index], options);
+        const childPrefix = childIsLast ? LinePrefix.LastChild : LinePrefix.Child;
+        const childMultilinePrefix = childIsLast ? LinePrefix.LastNestedChild : LinePrefix.NestedChild;
+        childLines.forEach((line) => {
+          if (line.depth === depth + 1) {
+            line.prefix = childPrefix + line.prefix;
+            line.multilinePrefix = childMultilinePrefix + line.multilinePrefix;
+          } else if (childIsLast) {
+            line.prefix = LinePrefix.LastNestedChild + line.prefix;
+            line.multilinePrefix = LinePrefix.LastNestedChild + line.multilinePrefix;
+          } else {
+            line.prefix = LinePrefix.NestedChild + line.prefix;
+            line.multilinePrefix = LinePrefix.NestedChild + line.multilinePrefix;
+          }
+        });
+        return childLines;
+      });
+      return [rootLine, ...nestedLines];
+    }
+    function directoryDiagram(node, options) {
+      const lines = nodeDiagram(node, [], options);
+      const strings = lines.map((line) => prefixBlock(line.label, line.prefix, line.multilinePrefix));
+      return strings.join("\n");
+    }
+    exports.directoryDiagram = directoryDiagram;
+    function isMultiline(line) {
+      return line.includes("\n");
+    }
+    exports.isMultiline = isMultiline;
+    function prefixBlock(block, prefix, multilinePrefix) {
+      if (!isMultiline(block))
+        return prefix + block;
+      return block.split("\n").map((line, index) => (index === 0 ? prefix : multilinePrefix) + line).join("\n");
+    }
+    exports.prefixBlock = prefixBlock;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/diagram.js
+var require_diagram = __commonJS({
+  "../../node_modules/tree-visit/lib/diagram.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.diagram = void 0;
+    var boxDiagram_1 = require_boxDiagram();
+    var directoryDiagram_1 = require_directoryDiagram();
+    function diagram(node, options) {
+      if (options.type === "box") {
+        return (0, boxDiagram_1.boxDiagram)(node, options);
+      }
+      return (0, directoryDiagram_1.directoryDiagram)(node, options);
+    }
+    exports.diagram = diagram;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/visit.js
+var require_visit = __commonJS({
+  "../../node_modules/tree-visit/lib/visit.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.visit = exports.STOP = exports.SKIP = void 0;
+    exports.SKIP = "skip";
+    exports.STOP = "stop";
+    function visit(node, options) {
+      const { onEnter, onLeave, getChildren, onDetectCycle, getIdentifier } = options;
+      let indexPath = [];
+      let stack = [{ node }];
+      const visited = onDetectCycle ? /* @__PURE__ */ new Set() : void 0;
+      const context = options.includeTraversalContext ? {
+        getRoot() {
+          return node;
+        },
+        getParent() {
+          var _a;
+          return (_a = stack[stack.length - 2]) === null || _a === void 0 ? void 0 : _a.node;
+        },
+        getAncestors() {
+          return stack.slice(0, -1).map((wrapper) => wrapper.node);
+        }
+      } : void 0;
+      const getIndexPath = options.reuseIndexPath ? () => indexPath : () => indexPath.slice();
+      while (stack.length > 0) {
+        let wrapper = stack[stack.length - 1];
+        if (wrapper.state === void 0) {
+          if (visited) {
+            const id = getIdentifier ? getIdentifier(wrapper.node) : wrapper.node;
+            if (visited.has(id)) {
+              const action = typeof onDetectCycle === "function" ? onDetectCycle(wrapper.node, getIndexPath(), context) : onDetectCycle;
+              if (action === "error") {
+                throw new Error("Cycle detected in tree");
+              } else {
+                wrapper.state = -1;
+                continue;
+              }
+            }
+            visited.add(id);
+          }
+          const enterResult = onEnter === null || onEnter === void 0 ? void 0 : onEnter(wrapper.node, getIndexPath());
+          if (enterResult === exports.STOP)
+            return;
+          wrapper.state = enterResult === exports.SKIP ? -1 : 0;
+        }
+        const children = wrapper.children || getChildren(wrapper.node, getIndexPath(), context);
+        if (!wrapper.children) {
+          wrapper.children = children;
+        }
+        if (wrapper.state !== -1) {
+          if (wrapper.state < children.length) {
+            let currentIndex = wrapper.state;
+            indexPath.push(currentIndex);
+            stack.push({ node: children[currentIndex] });
+            wrapper.state = currentIndex + 1;
+            continue;
+          }
+          const leaveResult = onLeave === null || onLeave === void 0 ? void 0 : onLeave(wrapper.node, getIndexPath());
+          if (leaveResult === exports.STOP)
+            return;
+        }
+        if (visited) {
+          const id = getIdentifier ? getIdentifier(wrapper.node) : wrapper.node;
+          visited.delete(id);
+        }
+        indexPath.pop();
+        stack.pop();
+      }
+    }
+    exports.visit = visit;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/find.js
+var require_find = __commonJS({
+  "../../node_modules/tree-visit/lib/find.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.findAllIndexPaths = exports.findIndexPath = exports.findAll = exports.find = void 0;
+    var visit_1 = require_visit();
+    function find(node, options) {
+      let found;
+      (0, visit_1.visit)(node, Object.assign(Object.assign({}, options), { onEnter: (child, indexPath) => {
+        if (options.predicate(child, indexPath)) {
+          found = child;
+          return visit_1.STOP;
+        }
+      } }));
+      return found;
+    }
+    exports.find = find;
+    function findAll(node, options) {
+      let found = [];
+      (0, visit_1.visit)(node, {
+        onEnter: (child, indexPath) => {
+          if (options.predicate(child, indexPath)) {
+            found.push(child);
+          }
+        },
+        getChildren: options.getChildren
+      });
+      return found;
+    }
+    exports.findAll = findAll;
+    function findIndexPath(node, options) {
+      let found;
+      (0, visit_1.visit)(node, {
+        onEnter: (child, indexPath) => {
+          if (options.predicate(child, indexPath)) {
+            found = [...indexPath];
+            return visit_1.STOP;
+          }
+        },
+        getChildren: options.getChildren
+      });
+      return found;
+    }
+    exports.findIndexPath = findIndexPath;
+    function findAllIndexPaths(node, options) {
+      let found = [];
+      (0, visit_1.visit)(node, {
+        onEnter: (child, indexPath) => {
+          if (options.predicate(child, indexPath)) {
+            found.push([...indexPath]);
+          }
+        },
+        getChildren: options.getChildren
+      });
+      return found;
+    }
+    exports.findAllIndexPaths = findAllIndexPaths;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/reduce.js
+var require_reduce = __commonJS({
+  "../../node_modules/tree-visit/lib/reduce.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.reduce = void 0;
+    var visit_1 = require_visit();
+    function reduce(node, options) {
+      let result = options.initialResult;
+      (0, visit_1.visit)(node, Object.assign(Object.assign({}, options), { onEnter: (child, indexPath) => {
+        result = options.nextResult(result, child, indexPath);
+      } }));
+      return result;
+    }
+    exports.reduce = reduce;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/flat.js
+var require_flat = __commonJS({
+  "../../node_modules/tree-visit/lib/flat.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.flat = void 0;
+    var reduce_1 = require_reduce();
+    function flat(node, options) {
+      return (0, reduce_1.reduce)(node, Object.assign(Object.assign({}, options), { initialResult: [], nextResult: (result, child) => {
+        result.push(child);
+        return result;
+      } }));
+    }
+    exports.flat = flat;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/flatMap.js
+var require_flatMap = __commonJS({
+  "../../node_modules/tree-visit/lib/flatMap.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.flatMap = void 0;
+    var reduce_1 = require_reduce();
+    function flatMap(node, options) {
+      return (0, reduce_1.reduce)(node, Object.assign(Object.assign({}, options), { initialResult: [], nextResult: (result, child, indexPath) => {
+        result.push(...options.transform(child, indexPath));
+        return result;
+      } }));
+    }
+    exports.flatMap = flatMap;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/map.js
+var require_map = __commonJS({
+  "../../node_modules/tree-visit/lib/map.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.map = void 0;
+    var visit_1 = require_visit();
+    function map(node, options) {
+      const childrenMap = {};
+      (0, visit_1.visit)(node, Object.assign(Object.assign({}, options), { onLeave: (child, indexPath) => {
+        var _a, _b;
+        const keyIndexPath = [0, ...indexPath];
+        const key = keyIndexPath.join();
+        const transformed = options.transform(child, (_a = childrenMap[key]) !== null && _a !== void 0 ? _a : [], indexPath);
+        const parentKey = keyIndexPath.slice(0, -1).join();
+        const parentChildren = (_b = childrenMap[parentKey]) !== null && _b !== void 0 ? _b : [];
+        parentChildren.push(transformed);
+        childrenMap[parentKey] = parentChildren;
+      } }));
+      return childrenMap[""][0];
+    }
+    exports.map = map;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/operation.js
+var require_operation = __commonJS({
+  "../../node_modules/tree-visit/lib/operation.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.splice = exports.applyOperations = exports.getReplaceOperations = exports.getRemovalOperations = exports.getInsertionOperations = exports.replaceOperation = exports.removeOperation = exports.insertOperation = void 0;
+    var ancestors_1 = require_ancestors();
+    var map_1 = require_map();
+    function insertOperation(index, nodes) {
+      return {
+        type: "insert",
+        index,
+        nodes
+      };
+    }
+    exports.insertOperation = insertOperation;
+    function removeOperation(indexes) {
+      return {
+        type: "remove",
+        indexes
+      };
+    }
+    exports.removeOperation = removeOperation;
+    function replaceOperation() {
+      return {
+        type: "replace"
+      };
+    }
+    exports.replaceOperation = replaceOperation;
+    function splitIndexPath(indexPath) {
+      return [indexPath.slice(0, -1), indexPath[indexPath.length - 1]];
+    }
+    function getInsertionOperations(indexPath, nodes, operations = /* @__PURE__ */ new Map()) {
+      var _a;
+      const [parentIndexPath, index] = splitIndexPath(indexPath);
+      for (let i = parentIndexPath.length - 1; i >= 0; i--) {
+        const parentKey = parentIndexPath.slice(0, i).join();
+        switch ((_a = operations.get(parentKey)) === null || _a === void 0 ? void 0 : _a.type) {
+          case "remove":
+            continue;
+        }
+        operations.set(parentKey, replaceOperation());
+      }
+      const operation = operations.get(parentIndexPath.join());
+      switch (operation === null || operation === void 0 ? void 0 : operation.type) {
+        case "remove":
+          operations.set(parentIndexPath.join(), {
+            type: "removeThenInsert",
+            removeIndexes: operation.indexes,
+            insertIndex: index,
+            insertNodes: nodes
+          });
+          break;
+        default:
+          operations.set(parentIndexPath.join(), insertOperation(index, nodes));
+      }
+      return operations;
+    }
+    exports.getInsertionOperations = getInsertionOperations;
+    function getRemovalOperations(indexPaths) {
+      var _a, _b;
+      const _ancestorIndexPaths = (0, ancestors_1.ancestorPaths)(indexPaths);
+      const indexesToRemove = /* @__PURE__ */ new Map();
+      for (const indexPath of _ancestorIndexPaths) {
+        const parentKey = indexPath.slice(0, -1).join();
+        const value = (_a = indexesToRemove.get(parentKey)) !== null && _a !== void 0 ? _a : [];
+        value.push(indexPath[indexPath.length - 1]);
+        indexesToRemove.set(parentKey, value);
+      }
+      const operations = /* @__PURE__ */ new Map();
+      for (const indexPath of _ancestorIndexPaths) {
+        for (let i = indexPath.length - 1; i >= 0; i--) {
+          const parentKey = indexPath.slice(0, i).join();
+          operations.set(parentKey, replaceOperation());
+        }
+      }
+      for (const indexPath of _ancestorIndexPaths) {
+        const parentKey = indexPath.slice(0, -1).join();
+        operations.set(parentKey, removeOperation((_b = indexesToRemove.get(parentKey)) !== null && _b !== void 0 ? _b : []));
+      }
+      return operations;
+    }
+    exports.getRemovalOperations = getRemovalOperations;
+    function getReplaceOperations(indexPath, node) {
+      const operations = /* @__PURE__ */ new Map();
+      const [parentIndexPath, index] = splitIndexPath(indexPath);
+      for (let i = parentIndexPath.length - 1; i >= 0; i--) {
+        const parentKey = parentIndexPath.slice(0, i).join();
+        operations.set(parentKey, replaceOperation());
+      }
+      operations.set(parentIndexPath.join(), {
+        type: "removeThenInsert",
+        removeIndexes: [index],
+        insertIndex: index,
+        insertNodes: [node]
+      });
+      return operations;
+    }
+    exports.getReplaceOperations = getReplaceOperations;
+    function applyOperations(node, operations, options) {
+      return (0, map_1.map)(node, Object.assign(Object.assign({}, options), {
+        // Avoid calling `getChildren` for every node in the tree.
+        // Return [] if we're just going to return the original node anyway.
+        getChildren: (node2, indexPath) => {
+          const key = indexPath.join();
+          const operation = operations.get(key);
+          switch (operation === null || operation === void 0 ? void 0 : operation.type) {
+            case "replace":
+            case "remove":
+            case "removeThenInsert":
+            case "insert":
+              return options.getChildren(node2, indexPath);
+            default:
+              return [];
+          }
+        },
+        transform: (node2, children, indexPath) => {
+          const key = indexPath.join();
+          const operation = operations.get(key);
+          switch (operation === null || operation === void 0 ? void 0 : operation.type) {
+            case "remove":
+              return options.create(node2, children.filter((_, index) => !operation.indexes.includes(index)), indexPath);
+            case "removeThenInsert":
+              const updatedChildren = children.filter((_, index) => !operation.removeIndexes.includes(index));
+              const adjustedIndex = operation.removeIndexes.reduce((index, removedIndex) => removedIndex < index ? index - 1 : index, operation.insertIndex);
+              return options.create(node2, splice(updatedChildren, adjustedIndex, 0, ...operation.insertNodes), indexPath);
+            case "insert":
+              return options.create(node2, splice(children, operation.index, 0, ...operation.nodes), indexPath);
+            case "replace":
+              return options.create(node2, children, indexPath);
+            default:
+              return node2;
+          }
+        }
+      }));
+    }
+    exports.applyOperations = applyOperations;
+    function splice(array, start, deleteCount, ...items) {
+      return [
+        ...array.slice(0, start),
+        ...items,
+        ...array.slice(start + deleteCount)
+      ];
+    }
+    exports.splice = splice;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/insert.js
+var require_insert = __commonJS({
+  "../../node_modules/tree-visit/lib/insert.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.insert = void 0;
+    var operation_1 = require_operation();
+    function insert(node, options) {
+      const { nodes, at } = options;
+      if (at.length === 0) {
+        throw new Error(`Can't insert nodes at the root`);
+      }
+      const state = (0, operation_1.getInsertionOperations)(at, nodes);
+      return (0, operation_1.applyOperations)(node, state, options);
+    }
+    exports.insert = insert;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/move.js
+var require_move = __commonJS({
+  "../../node_modules/tree-visit/lib/move.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.move = void 0;
+    var access_1 = require_access();
+    var ancestors_1 = require_ancestors();
+    var operation_1 = require_operation();
+    function move(node, options) {
+      if (options.indexPaths.length === 0)
+        return node;
+      for (const indexPath of options.indexPaths) {
+        if (indexPath.length === 0) {
+          throw new Error(`Can't move the root node`);
+        }
+      }
+      if (options.to.length === 0) {
+        throw new Error(`Can't move nodes to the root`);
+      }
+      const _ancestorIndexPaths = (0, ancestors_1.ancestorPaths)(options.indexPaths);
+      const nodesToInsert = _ancestorIndexPaths.map((indexPath) => (0, access_1.access)(node, indexPath, options));
+      const operations = (0, operation_1.getInsertionOperations)(options.to, nodesToInsert, (0, operation_1.getRemovalOperations)(_ancestorIndexPaths));
+      return (0, operation_1.applyOperations)(node, operations, options);
+    }
+    exports.move = move;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/remove.js
+var require_remove = __commonJS({
+  "../../node_modules/tree-visit/lib/remove.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.remove = void 0;
+    var operation_1 = require_operation();
+    function remove(node, options) {
+      if (options.indexPaths.length === 0)
+        return node;
+      for (const indexPath of options.indexPaths) {
+        if (indexPath.length === 0) {
+          throw new Error(`Can't remove the root node`);
+        }
+      }
+      const operations = (0, operation_1.getRemovalOperations)(options.indexPaths);
+      return (0, operation_1.applyOperations)(node, operations, options);
+    }
+    exports.remove = remove;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/replace.js
+var require_replace = __commonJS({
+  "../../node_modules/tree-visit/lib/replace.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.replace = void 0;
+    var operation_1 = require_operation();
+    function replace(node, options) {
+      if (options.at.length === 0)
+        return options.node;
+      const operations = (0, operation_1.getReplaceOperations)(options.at, options.node);
+      return (0, operation_1.applyOperations)(node, operations, options);
+    }
+    exports.replace = replace;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/defineTree.js
+var require_defineTree = __commonJS({
+  "../../node_modules/tree-visit/lib/defineTree.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.defineTree = void 0;
+    var access_1 = require_access();
+    var diagram_1 = require_diagram();
+    var find_1 = require_find();
+    var flat_1 = require_flat();
+    var flatMap_1 = require_flatMap();
+    var insert_1 = require_insert();
+    var map_1 = require_map();
+    var move_1 = require_move();
+    var reduce_1 = require_reduce();
+    var remove_1 = require_remove();
+    var replace_1 = require_replace();
+    var visit_1 = require_visit();
+    var Tree = class _Tree {
+      constructor(getChildrenOrBaseOptions, appliedOptions) {
+        this.appliedOptions = appliedOptions;
+        this.getChildren = (node, indexPath, context) => {
+          return this._getChildren(node, indexPath, context);
+        };
+        this.mergeOptions = (options) => Object.assign(Object.assign(Object.assign({}, this.baseOptions), this.appliedOptions), options);
+        this.withOptions = (newOptions) => new _Tree(this.baseOptions, Object.assign(Object.assign({}, this.appliedOptions), newOptions));
+        this.access = (node, indexPath) => (0, access_1.access)(node, indexPath, this.mergeOptions({}));
+        this.accessPath = (node, indexPath) => (0, access_1.accessPath)(node, indexPath, this.mergeOptions({}));
+        this.diagram = (node, options) => typeof options === "function" ? (0, diagram_1.diagram)(node, this.mergeOptions({ getLabel: options })) : (0, diagram_1.diagram)(node, this.mergeOptions(options));
+        this.find = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.find)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.find)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.findAll = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.findAll)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.findAll)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.findIndexPath = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.findIndexPath)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.findIndexPath)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.findAllIndexPaths = (node, predicateOrOptions) => typeof predicateOrOptions === "function" ? (0, find_1.findAllIndexPaths)(node, this.mergeOptions({ predicate: predicateOrOptions })) : (0, find_1.findAllIndexPaths)(node, this.mergeOptions(Object.assign({}, predicateOrOptions)));
+        this.flat = (node) => (0, flat_1.flat)(node, this.mergeOptions({}));
+        this.flatMap = (node, transform) => (0, flatMap_1.flatMap)(node, this.mergeOptions({ transform }));
+        this.reduce = (node, nextResult, initialResult) => (0, reduce_1.reduce)(node, this.mergeOptions({ nextResult, initialResult }));
+        this.map = (node, transform) => (0, map_1.map)(node, this.mergeOptions({ transform }));
+        this.visit = (node, onEnterOrOptions) => typeof onEnterOrOptions === "function" ? (0, visit_1.visit)(node, this.mergeOptions({ onEnter: onEnterOrOptions })) : (0, visit_1.visit)(node, this.mergeOptions(Object.assign({}, onEnterOrOptions)));
+        this.insert = (node, options) => (0, insert_1.insert)(node, this.mergeOptions(options));
+        this.remove = (node, options) => (0, remove_1.remove)(node, this.mergeOptions(options));
+        this.move = (node, options) => (0, move_1.move)(node, this.mergeOptions(options));
+        this.replace = (node, options) => (0, replace_1.replace)(node, this.mergeOptions(options));
+        this.baseOptions = typeof getChildrenOrBaseOptions === "function" ? { getChildren: getChildrenOrBaseOptions } : getChildrenOrBaseOptions;
+        this._getChildren = this.baseOptions.getChildren;
+      }
+    };
+    function defineTree2(getChildren) {
+      return new Tree(getChildren, {});
+    }
+    exports.defineTree = defineTree2;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/indexPath.js
+var require_indexPath = __commonJS({
+  "../../node_modules/tree-visit/lib/indexPath.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/tree-visit/lib/options.js
+var require_options = __commonJS({
+  "../../node_modules/tree-visit/lib/options.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/tree-visit/lib/withOptions.js
+var require_withOptions = __commonJS({
+  "../../node_modules/tree-visit/lib/withOptions.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.withOptions = void 0;
+    var defineTree_1 = require_defineTree();
+    exports.withOptions = defineTree_1.defineTree;
+  }
+});
+
+// ../../node_modules/tree-visit/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/tree-visit/lib/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_access(), exports);
+    __exportStar(require_ancestors(), exports);
+    __exportStar(require_defineTree(), exports);
+    __exportStar(require_diagram(), exports);
+    __exportStar(require_find(), exports);
+    __exportStar(require_flat(), exports);
+    __exportStar(require_flatMap(), exports);
+    __exportStar(require_indexPath(), exports);
+    __exportStar(require_insert(), exports);
+    __exportStar(require_map(), exports);
+    __exportStar(require_move(), exports);
+    __exportStar(require_options(), exports);
+    __exportStar(require_reduce(), exports);
+    __exportStar(require_remove(), exports);
+    __exportStar(require_replace(), exports);
+    __exportStar(require_sort(), exports);
+    __exportStar(require_visit(), exports);
+    __exportStar(require_withOptions(), exports);
+  }
+});
+
+// src/MediaCollection.tsx
+import {
+  ActionMenu,
+  createSectionedMenu,
+  cssVars,
+  FileExplorerCollection,
+  FileExplorerDetail,
+  FileExplorerEmptyState,
+  FileExplorerLayout,
+  FileExplorerUploadButton,
+  MediaThumbnail
+} from "@noya-app/noya-designsystem";
+import {
+  DownloadIcon,
+  FolderIcon,
+  InputIcon,
+  OpenInNewWindowIcon,
+  ResetIcon,
+  TrashIcon,
+  UpdateIcon,
+  UploadIcon
+} from "@noya-app/noya-icons";
+import {
+  useAsset,
+  useAssetManager,
+  useAssets
+} from "@noya-app/noya-multiplayer-react";
+import { groupBy, isDeepEqual } from "@noya-app/noya-utils";
+import {
+  downloadUrl,
+  memoGeneric,
+  useControlledOrUncontrolled
+} from "@noya-app/react-utils";
+import { fileOpen } from "browser-fs-access";
+import {
+  forwardRef,
+  memo,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+
+// src/utils/mediaItemTree.ts
+var import_tree_visit = __toESM(require_lib());
+import { uuid } from "@noya-app/noya-utils";
+import { path } from "imfs";
+var createMediaFolder = (folder) => {
+  return {
+    id: uuid(),
+    kind: "folder",
+    ...folder
+  };
+};
+var createMediaAsset = (asset) => {
+  return {
+    id: uuid(),
+    kind: "asset",
+    ...asset
+  };
+};
+var createMediaFile = (file) => {
+  return {
+    id: uuid(),
+    kind: "file",
+    ...file
+  };
+};
+var createMediaItem = (item) => {
+  return {
+    ...item
+  };
+};
+var rootMediaItem = {
+  id: "root",
+  kind: "folder"
+};
+var rootMediaItemPath = ".";
+var rootMediaItemName = "All Files";
+var PLACEHOLDER_ITEM_NAME = "placeholder";
+var createMediaItemTree = (mediaMap) => {
+  const sortedMediaMap = Object.fromEntries(
+    Object.entries(mediaMap).sort((a, b) => a[0].localeCompare(b[0]))
+  );
+  const parentToChildrenMap = /* @__PURE__ */ new Map();
+  const idToPathMap = /* @__PURE__ */ new Map();
+  idToPathMap.set(rootMediaItem.id, rootMediaItemPath);
+  for (const [itemPath, item] of Object.entries(sortedMediaMap)) {
+    const parentPath = path.dirname(itemPath);
+    const children = parentToChildrenMap.get(parentPath) ?? [];
+    children.push(item);
+    parentToChildrenMap.set(parentPath, children);
+    idToPathMap.set(item.id, itemPath);
+  }
+  const tree = (0, import_tree_visit.defineTree)({
+    getChildren: (item) => {
+      const itemPath = item === rootMediaItem ? rootMediaItemPath : idToPathMap.get(item.id);
+      if (!itemPath) return [];
+      return parentToChildrenMap.get(itemPath) ?? [];
+    },
+    onDetectCycle: "skip",
+    getIdentifier: (item) => item.id
+  });
+  const result = tree.withOptions({
+    getLabel: (item) => idToPathMap.get(item.id) ?? ""
+  });
+  const mediaItemsWithRoot = [...Object.values(sortedMediaMap), rootMediaItem];
+  const getNameForId = (id) => id === rootMediaItem.id ? rootMediaItemName : path.basename(idToPathMap.get(id) ?? "");
+  const getParentIdForId = (id) => {
+    const itemPath = idToPathMap.get(id);
+    if (!itemPath) return;
+    const parentPath = path.dirname(itemPath);
+    return idToPathMap.get(parentPath);
+  };
+  return {
+    ...result,
+    idToPathMap,
+    parentToChildrenMap,
+    mediaItemsWithRoot,
+    getParentIdForId,
+    getNameForId
+  };
+};
+
+// src/MediaCollection.tsx
+import { path as path3 } from "imfs";
+import React from "react";
+
+// src/utils/files.ts
+var import_tree_visit2 = __toESM(require_lib());
+import { path as path2 } from "imfs";
+var getVisibleItems = ({
+  expandedMap,
+  fileKindFilter,
+  rootItemId,
+  tree,
+  showAllDescendants,
+  showRootItem
+}) => {
+  const filteredItems = [];
+  const relativeRootItem = tree.find(rootMediaItem, (item) => item.id === rootItemId) ?? rootMediaItem;
+  tree.visit(relativeRootItem, (item) => {
+    if (relativeRootItem.id === item.id) {
+      if (showRootItem) {
+        filteredItems.push(item);
+      }
+      return;
+    }
+    if (item.kind === "file" && fileKindFilter === "all") {
+      filteredItems.push(item);
+    }
+    if (item.kind === "asset" && (fileKindFilter === "assets" || fileKindFilter === "all")) {
+      filteredItems.push(item);
+    }
+    if (item.kind === "folder" && (fileKindFilter === "directories" || fileKindFilter === "all")) {
+      filteredItems.push(item);
+    }
+    if (!expandedMap[item.id] || !showAllDescendants) return "skip";
+  });
+  return filteredItems;
+};
+var basenameValidator = (basename) => {
+  if (!basename || basename.trim() === "") return false;
+  const invalidCharsRegex = /[/\\<>:"|?*]/;
+  return !invalidCharsRegex.test(basename);
+};
+var validateMediaItemRename = ({
+  basename,
+  selectedItemPath,
+  media
+}) => {
+  if (!basenameValidator(basename)) return false;
+  const newItemPath = path2.join(path2.dirname(selectedItemPath), basename);
+  const newPathExists = media[newItemPath];
+  if (newPathExists) return false;
+  return true;
+};
+var movePathsIntoTarget = ({
+  media,
+  sourceItemPaths,
+  targetItemPath,
+  tree
+}) => {
+  const ancestors = (0, import_tree_visit2.ancestorPaths)(
+    sourceItemPaths.map((path4) => path4.split("/"))
+  );
+  const mediaClone = { ...media };
+  for (const ancestor of ancestors) {
+    const ancestorPath = ancestor.join("/");
+    const ancestorItem = mediaClone[ancestorPath];
+    const newAncestorPath = path2.join(
+      targetItemPath,
+      path2.basename(ancestorPath)
+    );
+    if (!ancestorItem) continue;
+    const descendantPaths = tree.flat(ancestorItem).map((item) => tree.idToPathMap.get(item.id));
+    for (const descendantPath of descendantPaths) {
+      if (!descendantPath) continue;
+      const newDescendantPath = descendantPath.replace(
+        ancestorPath,
+        newAncestorPath
+      );
+      const newPathIsValid = validateMediaItemRename({
+        basename: path2.basename(descendantPath),
+        selectedItemPath: newDescendantPath,
+        media
+      });
+      if (newPathIsValid) {
+        mediaClone[newDescendantPath] = mediaClone[descendantPath];
+        delete mediaClone[descendantPath];
+      }
+    }
+  }
+  return mediaClone;
+};
+var moveUpAFolder = ({
+  tree,
+  media,
+  selectedIds
+}) => {
+  const indexPath = tree.findIndexPath(
+    rootMediaItem,
+    (item) => item.id === selectedIds[0]
+  );
+  if (!indexPath) return;
+  const grandparentFolder = tree.access(
+    rootMediaItem,
+    indexPath.slice(0, indexPath.length - 2)
+  );
+  const grandparentFolderPath = tree.idToPathMap.get(grandparentFolder.id);
+  if (!grandparentFolderPath) return;
+  const sourceItemPaths = selectedIds.map((id) => tree.idToPathMap.get(id)).filter((path4) => Boolean(path4));
+  return movePathsIntoTarget({
+    media,
+    targetItemPath: grandparentFolderPath,
+    sourceItemPaths,
+    tree
+  });
+};
+var getDepthMap = (item, tree, showAllDescendants) => {
+  const depthMap = {};
+  tree.visit(item, (item2, indexPath) => {
+    if (showAllDescendants) {
+      depthMap[item2.id] = Math.max(indexPath.length - 1, 0);
+    } else {
+      depthMap[item2.id] = 0;
+    }
+  });
+  return depthMap;
+};
+var updateExpandedMap = ({
+  item,
+  expanded,
+  expandable,
+  expandedMap,
+  tree
+}) => {
+  const newExpandedMap = { ...expandedMap };
+  const inner = (item2, expanded2) => {
+    if (!expandable) return {};
+    if (item2.id === rootMediaItem.id) return {};
+    if (!expanded2) {
+      const children = tree.getChildren(item2, []);
+      children.forEach((child) => inner(child, false));
+    }
+    newExpandedMap[item2.id] = expanded2;
+  };
+  inner(item, expanded);
+  return newExpandedMap;
+};
+var deleteMediaItems = ({
+  selectedIds,
+  media,
+  tree
+}) => {
+  const itemsToDelete = selectedIds.flatMap((mediaItemId) => {
+    const mediaItem = tree.mediaItemsWithRoot.find(
+      (item) => item.id === mediaItemId
+    );
+    if (!mediaItem) return [];
+    return tree.flat(mediaItem);
+  });
+  const itemKeysToDelete = new Set(
+    itemsToDelete.map((item) => tree.idToPathMap.get(item.id))
+  );
+  return Object.fromEntries(
+    Object.entries(media).filter(([key]) => !itemKeysToDelete.has(key))
+  );
+};
+var moveMediaInsideFolder = ({
+  sourceItemIds,
+  targetItemId,
+  media,
+  tree
+}) => {
+  const targetItemPath = tree.idToPathMap.get(targetItemId);
+  if (!targetItemPath) return media;
+  const sourceItemPaths = sourceItemIds.map((id) => tree.idToPathMap.get(id)).filter((path4) => Boolean(path4));
+  return movePathsIntoTarget({
+    media,
+    sourceItemPaths,
+    targetItemPath,
+    tree
+  });
+};
+var getParentDirectories = (mediaMap, folderId) => {
+  const tree = createMediaItemTree(mediaMap);
+  const indexPath = tree.findIndexPath(
+    rootMediaItem,
+    (item) => item.id === folderId
+  );
+  if (!indexPath) return [rootMediaItem];
+  return tree.accessPath(rootMediaItem, indexPath);
+};
+
+// src/MediaCollection.tsx
+var MediaThumbnailInternal = memoGeneric(
+  ({ item, selected }) => {
+    const asset = useAsset(item.kind === "asset" ? item.assetId : void 0);
+    const isRoot = item.id === rootMediaItem.id;
+    const isFolder = item.kind === "folder";
+    return /* @__PURE__ */ React.createElement(
+      MediaThumbnail,
+      {
+        contentType: asset?.contentType,
+        iconName: isRoot ? "HomeIcon" : isFolder ? "FolderIcon" : void 0,
+        url: asset?.url,
+        selected
+      }
+    );
+  }
+);
+var MediaCollection = memo(
+  forwardRef(function MediaCollection2({
+    onSelectionChange,
+    selectedIds: selectedIdsProp,
+    media,
+    setMedia,
+    viewType = "list",
+    fileKindFilter = "all",
+    showRootItem = false,
+    initialExpanded,
+    expandable = true,
+    renamable = true,
+    onDoubleClickItem,
+    rootItemId = rootMediaItem.id,
+    title,
+    size = "medium",
+    right,
+    renderAction: renderActionProp,
+    className,
+    showUploadButton = true,
+    showAllDescendants = true,
+    scrollable = false,
+    sortable = false,
+    renderEmptyState
+  }, ref) {
+    const tree = useMemo(() => createMediaItemTree(media), [media]);
+    const [tempItem, setTempItem] = useState(
+      void 0
+    );
+    const treeWithTempItem = useMemo(
+      () => createMediaItemTree({
+        ...media,
+        ...tempItem ? { [tempItem[0]]: tempItem[1] } : {}
+      }),
+      [media, tempItem]
+    );
+    const [selectedIds, setSelectedIds] = useControlledOrUncontrolled(
+      {
+        defaultValue: [],
+        value: selectedIdsProp,
+        onChange: onSelectionChange
+      }
+    );
+    const assetManager = useAssetManager();
+    const assets = useAssets();
+    const [expandedMap, setExpandedMap] = useState({});
+    const visibleItems = useMemo(
+      () => getVisibleItems({
+        expandedMap,
+        fileKindFilter,
+        rootItemId,
+        tree: treeWithTempItem,
+        showAllDescendants,
+        showRootItem
+      }),
+      [
+        expandedMap,
+        fileKindFilter,
+        rootItemId,
+        treeWithTempItem,
+        showAllDescendants,
+        showRootItem
+      ]
+    );
+    const depthMap = useMemo(
+      () => getDepthMap(rootMediaItem, treeWithTempItem, showAllDescendants),
+      [treeWithTempItem, showAllDescendants]
+    );
+    const collectionRef = useRef(null);
+    const selectedMediaItems = useMemo(
+      () => treeWithTempItem.mediaItemsWithRoot.filter(
+        (item) => selectedIds.includes(item.id)
+      ),
+      [treeWithTempItem, selectedIds]
+    );
+    const groupedItems = groupBy(selectedMediaItems, (item) => item.kind);
+    const selectedAssetItems = groupedItems.asset ?? [];
+    const selectedFolderItems = groupedItems.folder ?? [];
+    const singleItemSelected = selectedMediaItems.length === 1;
+    const onlyAssetsSelected = selectedAssetItems.length > 0 && selectedAssetItems.length === selectedMediaItems.length;
+    const onlyFoldersSelected = selectedFolderItems.length > 0 && selectedFolderItems.length === selectedMediaItems.length;
+    const onlySingleFolderSelected = onlyFoldersSelected && selectedFolderItems.length === 1;
+    const onlySingleAssetSelected = onlyAssetsSelected && selectedAssetItems.length === 1;
+    const rootSelected = selectedIds.includes(rootMediaItem.id);
+    const sameParentSelected = selectedMediaItems.every((item) => {
+      const itemPath = tree.idToPathMap.get(item.id);
+      const firstSelectedPath = tree.idToPathMap.get(selectedIds[0]);
+      if (!itemPath || !firstSelectedPath) return false;
+      return itemPath.startsWith(path3.dirname(firstSelectedPath));
+    });
+    const gridSize = useMemo(() => {
+      if (viewType === "grid") {
+        return size;
+      }
+      return "medium";
+    }, [viewType, size]);
+    useEffect(() => {
+      if (initialExpanded) {
+        setExpandedMap(initialExpanded);
+      }
+    }, [initialExpanded]);
+    const handleExpanded = useCallback(
+      (item) => {
+        if (!expandable) return void 0;
+        if (item.kind !== "folder") return void 0;
+        if (item.id === rootMediaItem.id) return void 0;
+        return expandedMap[item.id] ?? false;
+      },
+      [expandedMap, expandable]
+    );
+    const handleDelete = useCallback(
+      (selectedIds2) => {
+        const newMedia = deleteMediaItems({
+          selectedIds: selectedIds2,
+          media,
+          tree
+        });
+        setSelectedIds([rootMediaItem.id]);
+        setMedia({ name: "Delete items", timestamp: Date.now() }, newMedia);
+      },
+      [media, setMedia, setSelectedIds, tree]
+    );
+    const onRename = useCallback(
+      (selectedItem, newName) => {
+        if (!renamable) return;
+        const selectedItemPath = treeWithTempItem.idToPathMap.get(
+          selectedItem.id
+        );
+        if (!selectedItemPath) return;
+        const mediaWithTempItem = {
+          ...media,
+          ...tempItem ? { [tempItem[0]]: tempItem[1] } : {}
+        };
+        const renameIsValid = validateMediaItemRename({
+          basename: newName,
+          selectedItemPath,
+          media: mediaWithTempItem
+        });
+        if (!renameIsValid) {
+          setTempItem(void 0);
+          return;
+        }
+        const mediaClone = { ...media };
+        delete mediaClone[selectedItemPath];
+        setMedia(
+          { name: "Rename media item", timestamp: Date.now() },
+          {
+            ...mediaClone,
+            [path3.join(path3.dirname(selectedItemPath), newName)]: selectedItem
+          }
+        );
+        setTempItem(void 0);
+      },
+      [media, renamable, setMedia, tempItem, treeWithTempItem.idToPathMap]
+    );
+    const handleAddFolder = useCallback(
+      (currentFolderId) => {
+        const newFolder = createMediaFolder();
+        const currentFolderPath = tree.idToPathMap.get(currentFolderId);
+        if (!currentFolderPath) return;
+        setTempItem([
+          path3.join(currentFolderPath, PLACEHOLDER_ITEM_NAME),
+          newFolder
+        ]);
+        setTimeout(() => {
+          collectionRef.current?.editName(newFolder.id);
+        }, 50);
+      },
+      [tree]
+    );
+    const handleAddFile = useCallback(
+      (currentFolderId) => {
+        const newFile = createMediaFile({
+          content: "",
+          encoding: "utf-8"
+        });
+        const currentFolderPath = tree.idToPathMap.get(
+          currentFolderId ?? rootMediaItem.id
+        );
+        if (!currentFolderPath) return;
+        setTempItem([
+          path3.join(currentFolderPath, PLACEHOLDER_ITEM_NAME),
+          newFile
+        ]);
+        setTimeout(() => {
+          collectionRef.current?.editName(newFile.id);
+        }, 50);
+      },
+      [tree.idToPathMap]
+    );
+    const handleMoveUpAFolder = useCallback(
+      (selectedIds2) => {
+        const newMedia = moveUpAFolder({
+          tree,
+          media,
+          selectedIds: selectedIds2
+        });
+        if (!newMedia) return;
+        setMedia({ name: "Move items", timestamp: Date.now() }, newMedia);
+      },
+      [media, tree, setMedia]
+    );
+    const handleUpload = useCallback(
+      async (selectedId) => {
+        try {
+          const files = await fileOpen({ multiple: true });
+          if (!files || !Array.isArray(files) || files.length === 0) return;
+          const parentPath = tree.idToPathMap.get(selectedId);
+          if (!parentPath) return;
+          const uploadPromises = files.map(async (file) => {
+            const asset = await assetManager.create(file);
+            const assetPath = path3.join(parentPath, path3.basename(file.name));
+            return {
+              assetPath,
+              asset: createMediaAsset({ assetId: asset.id })
+            };
+          });
+          const newMediaMap = await Promise.all(uploadPromises);
+          setMedia(
+            { name: "Add media items", timestamp: Date.now() },
+            {
+              ...media,
+              ...Object.fromEntries(
+                newMediaMap.map(({ assetPath, asset }) => [assetPath, asset])
+              )
+            }
+          );
+        } catch (error) {
+          console.error("Failed to upload files:", error);
+        }
+      },
+      [tree.idToPathMap, setMedia, media, assetManager]
+    );
+    const handleDownload = useCallback(
+      async (selectedItems) => {
+        const downloadPromises = selectedItems.filter((item) => item.kind === "asset").map(async (item) => {
+          const asset = assets.find((a) => a.id === item.assetId);
+          if (!asset?.url) return;
+          return downloadUrl(asset.url, tree.getNameForId(item.id));
+        });
+        await Promise.all(downloadPromises);
+      },
+      [assets, tree]
+    );
+    const handlePreview = useCallback(
+      async (selectedItems) => {
+        const previewPromises = selectedItems.filter((item) => item.kind === "asset").map(async (item) => {
+          const asset = assets.find((a) => a.id === item.assetId);
+          if (!asset?.url) return;
+          return window?.open(asset.url, "_blank");
+        });
+        await Promise.all(previewPromises);
+      },
+      [assets]
+    );
+    const handleReplace = useCallback(
+      async (selectedItem) => {
+        try {
+          const file = await fileOpen();
+          if (!file) return;
+          const asset = await assetManager.create(file);
+          const oldFile = selectedItem;
+          const oldFilePath = tree.idToPathMap.get(oldFile.id);
+          if (!oldFilePath || oldFile.kind !== "asset") return;
+          setMedia(
+            { name: "Replace media file", timestamp: Date.now() },
+            {
+              ...media,
+              [oldFilePath]: createMediaAsset({
+                ...oldFile,
+                assetId: asset.id
+              })
+            }
+          );
+        } catch (error) {
+          console.error("Failed to upload file:", error);
+        }
+      },
+      [media, setMedia, assetManager, tree]
+    );
+    const handleRename = useCallback(
+      (selectedItemId) => {
+        collectionRef.current?.editName(selectedItemId);
+      },
+      [collectionRef]
+    );
+    const handleMoveMediaInsideFolder = useCallback(
+      (sourceItem, targetItem) => {
+        const sourceItemPath = tree.idToPathMap.get(sourceItem.id);
+        const targetItemPath = tree.idToPathMap.get(targetItem.id);
+        if (!sourceItemPath || !targetItemPath) return;
+        const newMedia = moveMediaInsideFolder({
+          sourceItemIds: [sourceItem.id],
+          targetItemId: targetItem.id,
+          media,
+          tree
+        });
+        setMedia(
+          {
+            name: "Move media file inside folder",
+            timestamp: Date.now()
+          },
+          newMedia
+        );
+      },
+      [media, setMedia, tree]
+    );
+    const assetContextMenuItems = useMemo(() => {
+      return createSectionedMenu(
+        [
+          !rootSelected && singleItemSelected && {
+            title: "Rename",
+            value: "rename",
+            icon: /* @__PURE__ */ React.createElement(InputIcon, null)
+          },
+          onlySingleAssetSelected && {
+            title: "Replace",
+            value: "replace",
+            icon: /* @__PURE__ */ React.createElement(UpdateIcon, null)
+          },
+          !rootSelected && {
+            title: "Delete",
+            value: "delete",
+            icon: /* @__PURE__ */ React.createElement(TrashIcon, null)
+          }
+        ],
+        [
+          onlySingleFolderSelected && {
+            title: "Add media",
+            value: "upload",
+            icon: /* @__PURE__ */ React.createElement(UploadIcon, null)
+          },
+          onlySingleFolderSelected && {
+            title: "Add a Folder",
+            value: "addFolder",
+            icon: /* @__PURE__ */ React.createElement(FolderIcon, null)
+          },
+          onlyAssetsSelected && tree.mediaItemsWithRoot.length > 0 && {
+            title: "Download",
+            value: "download",
+            icon: /* @__PURE__ */ React.createElement(DownloadIcon, null)
+          },
+          onlySingleAssetSelected && {
+            title: "Preview",
+            value: "preview",
+            icon: /* @__PURE__ */ React.createElement(OpenInNewWindowIcon, null)
+          }
+        ],
+        [
+          !rootSelected && sameParentSelected && {
+            title: "Move up a folder",
+            value: "move",
+            icon: /* @__PURE__ */ React.createElement(ResetIcon, null)
+          }
+        ]
+      );
+    }, [
+      rootSelected,
+      singleItemSelected,
+      onlySingleAssetSelected,
+      onlySingleFolderSelected,
+      onlyAssetsSelected,
+      tree.mediaItemsWithRoot.length,
+      sameParentSelected
+    ]);
+    const handleMenuAction = useCallback(
+      async (action, selectedItems) => {
+        if (selectedItems.length === 0) return;
+        switch (action) {
+          case "rename":
+            handleRename(selectedItems[0].id);
+            return;
+          case "delete":
+            handleDelete(selectedIds);
+            return;
+          case "replace":
+            handleReplace(selectedItems[0]);
+            return;
+          case "upload":
+            handleUpload(selectedItems[0].id);
+            return;
+          case "addFolder":
+            handleAddFolder(selectedItems[0].id);
+            return;
+          case "preview":
+            handlePreview(selectedItems);
+            return;
+          case "download":
+            handleDownload(selectedItems);
+            return;
+          case "move":
+            handleMoveUpAFolder(selectedIds);
+            return;
+        }
+      },
+      [
+        handleRename,
+        handleDelete,
+        selectedIds,
+        handleReplace,
+        handleUpload,
+        handleAddFolder,
+        handlePreview,
+        handleDownload,
+        handleMoveUpAFolder
+      ]
+    );
+    const handleSetExpanded = useCallback(
+      (item, expanded) => {
+        setExpandedMap(
+          (prev) => updateExpandedMap({
+            item,
+            expanded,
+            expandable,
+            expandedMap: prev,
+            tree
+          })
+        );
+      },
+      [expandable, tree]
+    );
+    const renderAction = useMemo(() => {
+      if (renderActionProp) return renderActionProp;
+      return ({
+        selected,
+        onOpenChange
+      }) => /* @__PURE__ */ React.createElement(
+        ActionMenu,
+        {
+          menuItems: assetContextMenuItems,
+          onSelect: (action) => handleMenuAction(action, selectedMediaItems),
+          selected,
+          onOpenChange,
+          style: {
+            backgroundColor: selected ? cssVars.colors.primaryPastel : "transparent"
+          }
+        }
+      );
+    }, [
+      assetContextMenuItems,
+      handleMenuAction,
+      renderActionProp,
+      selectedMediaItems
+    ]);
+    useImperativeHandle(ref, () => ({
+      upload: (selectedId) => handleUpload(selectedId),
+      delete: handleDelete,
+      download: handleDownload,
+      rename: handleRename,
+      addFolder: handleAddFolder,
+      addFile: handleAddFile,
+      moveUpAFolder: handleMoveUpAFolder,
+      replace: handleReplace,
+      preview: handlePreview,
+      moveMediaInsideFolder: handleMoveMediaInsideFolder
+    }));
+    return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+      FileExplorerLayout,
+      {
+        title: title ?? rootMediaItemName,
+        right: /* @__PURE__ */ React.createElement(
+          FileExplorerUploadButton,
+          {
+            showUploadButton,
+            onUpload: () => handleUpload(rootMediaItem.id)
+          },
+          right
+        ),
+        className
+      },
+      /* @__PURE__ */ React.createElement(
+        FileExplorerCollection,
+        {
+          ref: collectionRef,
+          scrollable,
+          items: visibleItems,
+          viewType,
+          size: gridSize,
+          getId: (file) => file.id,
+          getName: (file) => {
+            if (file.id === tempItem?.[1].id) {
+              return "";
+            }
+            return treeWithTempItem.getNameForId(file.id);
+          },
+          expandable,
+          sortable,
+          getPlaceholder: (item) => {
+            switch (item.kind) {
+              case "folder":
+                return "Enter folder name";
+              case "asset":
+              case "file":
+                return "Enter file name";
+            }
+          },
+          getExpanded: handleExpanded,
+          setExpanded: handleSetExpanded,
+          getRenamable: (item) => {
+            if (item.id === rootMediaItem.id) return false;
+            return true;
+          },
+          getDepth: (item) => depthMap[item.id],
+          menuItems: assetContextMenuItems,
+          onSelectMenuItem: handleMenuAction,
+          onSelectionChange: setSelectedIds,
+          onDoubleClickItem,
+          onRename,
+          renamable,
+          selectedIds,
+          renderThumbnail: (props) => /* @__PURE__ */ React.createElement(MediaThumbnailInternal, { ...props }),
+          renderAction,
+          renderDetail: (file, selected) => {
+            if (file.kind !== "asset") return null;
+            const asset = assets.find((a) => a.id === file.assetId);
+            if (!asset) return null;
+            return /* @__PURE__ */ React.createElement(FileExplorerDetail, { selected }, (asset.size / 1024).toFixed(1), "KB");
+          },
+          renderEmptyState: () => renderEmptyState?.() ?? /* @__PURE__ */ React.createElement(FileExplorerEmptyState, null),
+          itemRoleDescription: "clickable file item",
+          getDropTargetParentIndex: (overIndex) => {
+            const item = visibleItems[overIndex];
+            const parentIndex = visibleItems.findIndex(
+              (i) => i.id === tree.getParentIdForId(item.id)
+            );
+            return parentIndex === -1 ? void 0 : parentIndex;
+          },
+          acceptsDrop: (sourceIndex, targetIndex, position) => {
+            const sourceItem = visibleItems[sourceIndex];
+            const targetItem = visibleItems[targetIndex];
+            if (position !== "inside" || targetItem.kind === "asset") {
+              return false;
+            }
+            const sourcePath = tree.findIndexPath(
+              rootMediaItem,
+              (item) => item.id === sourceItem.id
+            );
+            const targetPath = tree.findIndexPath(
+              rootMediaItem,
+              (item) => item.id === targetItem.id
+            );
+            if (!sourcePath || !targetPath) return false;
+            if (isDeepEqual(sourcePath, targetPath.slice(0, sourcePath.length))) {
+              return false;
+            }
+            return true;
+          },
+          onMoveItem: (sourceIndex, targetIndex, position) => {
+            const sourceItem = visibleItems[sourceIndex];
+            const targetItem = visibleItems[targetIndex];
+            if (position === "inside") {
+              handleMoveMediaInsideFolder(sourceItem, targetItem);
+            }
+          },
+          onFilesDrop: async (event) => {
+            event.preventDefault();
+            const files = Array.from(event.dataTransfer.files);
+            if (files.length === 0) return;
+            try {
+              const uploadPromises = files.map(async (file) => {
+                const asset = await assetManager.create(file);
+                return {
+                  asset: createMediaAsset({
+                    assetId: asset.id
+                  }),
+                  name: file.name
+                };
+              });
+              const newMediaItems = await Promise.all(uploadPromises);
+              const rootItemPath = tree.idToPathMap.get(rootItemId);
+              if (!rootItemPath) return;
+              setMedia(
+                { name: "Add media files", timestamp: Date.now() },
+                {
+                  ...media,
+                  ...Object.fromEntries(
+                    newMediaItems.map((item) => [
+                      path3.join(rootItemPath, item.name),
+                      item.asset
+                    ])
+                  )
+                }
+              );
+            } catch (error) {
+              console.error("Failed to upload dropped files:", error);
+            }
+          }
+        }
+      )
+    ));
+  })
+);
+export {
+  MediaCollection,
+  PLACEHOLDER_ITEM_NAME,
+  basenameValidator,
+  createMediaAsset,
+  createMediaFile,
+  createMediaFolder,
+  createMediaItem,
+  createMediaItemTree,
+  deleteMediaItems,
+  getDepthMap,
+  getParentDirectories,
+  getVisibleItems,
+  moveMediaInsideFolder,
+  movePathsIntoTarget,
+  moveUpAFolder,
+  rootMediaItem,
+  rootMediaItemName,
+  rootMediaItemPath,
+  updateExpandedMap,
+  validateMediaItemRename
+};
+//# sourceMappingURL=index.mjs.map