@alexgorbatchev/shadcn 0.0.46 → 0.0.47

package/dist/components/tree/index.js

@@ -254,22 +254,2225 @@ function Tree({
     ]
   });
 }
+// node_modules/@headless-tree/react/dist/chunk-FWCSY2DS.mjs
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 
-// src/components/tree/index.ts
-import { useTree, AssistiveTreeDescription } from "@headless-tree/react";
-import {
-  syncDataLoaderFeature,
-  asyncDataLoaderFeature,
-  hotkeysCoreFeature,
-  selectionFeature,
-  checkboxesFeature,
-  searchFeature,
-  renamingFeature,
-  expandAllFeature,
-  dragAndDropFeature,
-  keyboardDragAndDropFeature,
-  isOrderedDragTarget
-} from "@headless-tree/core";
+// node_modules/@headless-tree/react/dist/index.mjs
+import React from "react";
+
+// node_modules/@headless-tree/core/dist/index.mjs
+var __defProp2 = Object.defineProperty;
+var __defProps2 = Object.defineProperties;
+var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp2 = (obj, key, value) => (key in obj) ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b)) {
+      if (__propIsEnum2.call(b, prop))
+        __defNormalProp2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var memo = (deps, fn) => {
+  let value;
+  let oldDeps = null;
+  return (...a) => {
+    const newDeps = deps(...a);
+    if (!value) {
+      value = fn(...newDeps);
+      oldDeps = newDeps;
+      return value;
+    }
+    const match = oldDeps && oldDeps.length === newDeps.length && !oldDeps.some((dep, i) => dep !== newDeps[i]);
+    if (match) {
+      return value;
+    }
+    value = fn(...newDeps);
+    oldDeps = newDeps;
+    return value;
+  };
+};
+function functionalUpdate(updater, input) {
+  return typeof updater === "function" ? updater(input) : updater;
+}
+function makeStateUpdater(key, instance) {
+  return (updater) => {
+    instance.setState((old) => {
+      return __spreadProps2(__spreadValues2({}, old), {
+        [key]: functionalUpdate(updater, old[key])
+      });
+    });
+  };
+}
+var poll = (fn, interval = 100, timeout = 1000) => new Promise((resolve) => {
+  let clear;
+  const i = setInterval(() => {
+    if (fn()) {
+      resolve();
+      clearInterval(i);
+      clearTimeout(clear);
+    }
+  }, interval);
+  clear = setTimeout(() => {
+    clearInterval(i);
+    resolve();
+  }, timeout);
+});
+var prefix = "Headless Tree: ";
+var throwError = (message) => Error(prefix + message);
+var logWarning = (message) => console.warn(prefix + message);
+var treeFeature = {
+  key: "tree",
+  getInitialState: (initialState) => __spreadValues2({
+    expandedItems: [],
+    focusedItem: null
+  }, initialState),
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    setExpandedItems: makeStateUpdater("expandedItems", tree),
+    setFocusedItem: makeStateUpdater("focusedItem", tree)
+  }, defaultConfig),
+  stateHandlerNames: {
+    expandedItems: "setExpandedItems",
+    focusedItem: "setFocusedItem"
+  },
+  treeInstance: {
+    getItemsMeta: ({ tree }) => {
+      const { rootItemId } = tree.getConfig();
+      const { expandedItems } = tree.getState();
+      const flatItems = [];
+      const expandedItemsSet = new Set(expandedItems);
+      const recursiveAdd = (itemId, path, level, setSize, posInSet) => {
+        var _a;
+        if (path.includes(itemId)) {
+          logWarning(`Circular reference for ${path.join(".")}`);
+          return;
+        }
+        flatItems.push({
+          itemId,
+          level,
+          index: flatItems.length,
+          parentId: path.at(-1),
+          setSize,
+          posInSet
+        });
+        if (expandedItemsSet.has(itemId)) {
+          const children2 = (_a = tree.retrieveChildrenIds(itemId)) != null ? _a : [];
+          let i2 = 0;
+          for (const childId of children2) {
+            recursiveAdd(childId, path.concat(itemId), level + 1, children2.length, i2++);
+          }
+        }
+      };
+      const children = tree.retrieveChildrenIds(rootItemId);
+      let i = 0;
+      for (const itemId of children) {
+        recursiveAdd(itemId, [rootItemId], 0, children.length, i++);
+      }
+      return flatItems;
+    },
+    getFocusedItem: ({ tree }) => {
+      var _a;
+      const focusedItemId = tree.getState().focusedItem;
+      return (_a = focusedItemId !== null ? tree.getItemInstance(focusedItemId) : null) != null ? _a : tree.getItems()[0];
+    },
+    getRootItem: ({ tree }) => {
+      const { rootItemId } = tree.getConfig();
+      return tree.getItemInstance(rootItemId);
+    },
+    focusNextItem: ({ tree }) => {
+      var _a;
+      const focused = tree.getFocusedItem().getItemMeta();
+      if (!focused)
+        return;
+      const nextIndex = Math.min(focused.index + 1, tree.getItems().length - 1);
+      (_a = tree.getItems()[nextIndex]) == null || _a.setFocused();
+    },
+    focusPreviousItem: ({ tree }) => {
+      var _a;
+      const focused = tree.getFocusedItem().getItemMeta();
+      if (!focused)
+        return;
+      const nextIndex = Math.max(focused.index - 1, 0);
+      (_a = tree.getItems()[nextIndex]) == null || _a.setFocused();
+    },
+    updateDomFocus: ({ tree }) => {
+      setTimeout(() => __async(null, null, function* () {
+        var _a, _b, _c, _d, _e;
+        const focusedItem = tree.getFocusedItem();
+        (_b = (_a = tree.getConfig()).scrollToItem) == null || _b.call(_a, focusedItem);
+        yield poll(() => focusedItem.getElement() !== null, 20, 500);
+        const focusedElement = focusedItem.getElement();
+        if (!focusedElement) {
+          (_c = tree.getItems()[0]) == null || _c.setFocused();
+          (_e = (_d = tree.getItems()[0]) == null ? undefined : _d.getElement()) == null || _e.focus();
+          return;
+        }
+        focusedElement.focus();
+      }));
+    },
+    getContainerProps: ({ prev, tree }, treeLabel) => __spreadProps2(__spreadValues2({}, prev == null ? undefined : prev()), {
+      role: "tree",
+      "aria-label": treeLabel != null ? treeLabel : "",
+      ref: tree.registerElement
+    }),
+    isSearchOpen: () => false
+  },
+  itemInstance: {
+    scrollTo: (_0, _1) => __async(null, [_0, _1], function* ({ tree, item }, scrollIntoViewArg) {
+      var _a, _b, _c;
+      (_b = (_a = tree.getConfig()).scrollToItem) == null || _b.call(_a, item);
+      yield poll(() => item.getElement() !== null, 20);
+      (_c = item.getElement()) == null || _c.scrollIntoView(scrollIntoViewArg);
+    }),
+    getId: ({ itemId }) => itemId,
+    getKey: ({ itemId }) => itemId,
+    getProps: ({ item, prev }) => {
+      const itemMeta = item.getItemMeta();
+      return __spreadProps2(__spreadValues2({}, prev == null ? undefined : prev()), {
+        ref: item.registerElement,
+        role: "treeitem",
+        "aria-setsize": itemMeta.setSize,
+        "aria-posinset": itemMeta.posInSet + 1,
+        "aria-selected": "false",
+        "aria-label": item.getItemName(),
+        "aria-level": itemMeta.level + 1,
+        "aria-expanded": item.isFolder() ? item.isExpanded() : undefined,
+        tabIndex: item.isFocused() ? 0 : -1,
+        onClick: (e) => {
+          item.setFocused();
+          item.primaryAction();
+          if (e.ctrlKey || e.shiftKey || e.metaKey) {
+            return;
+          }
+          if (!item.isFolder()) {
+            return;
+          }
+          if (item.isExpanded()) {
+            item.collapse();
+          } else {
+            item.expand();
+          }
+        }
+      });
+    },
+    expand: ({ tree, item, itemId }) => {
+      var _a;
+      if (!item.isFolder()) {
+        return;
+      }
+      if ((_a = tree.getState().loadingItemChildrens) == null ? undefined : _a.includes(itemId)) {
+        return;
+      }
+      tree.applySubStateUpdate("expandedItems", (expandedItems) => [
+        ...expandedItems,
+        itemId
+      ]);
+      tree.rebuildTree();
+    },
+    collapse: ({ tree, item, itemId }) => {
+      if (!item.isFolder()) {
+        return;
+      }
+      tree.applySubStateUpdate("expandedItems", (expandedItems) => expandedItems.filter((id) => id !== itemId));
+      tree.rebuildTree();
+    },
+    getItemData: ({ tree, itemId }) => tree.retrieveItemData(itemId),
+    equals: ({ item }, other) => item.getId() === (other == null ? undefined : other.getId()),
+    isExpanded: ({ tree, itemId }) => tree.getState().expandedItems.includes(itemId),
+    isDescendentOf: ({ item }, parentId) => {
+      const parent = item.getParent();
+      return Boolean((parent == null ? undefined : parent.getId()) === parentId || (parent == null ? undefined : parent.isDescendentOf(parentId)));
+    },
+    isFocused: ({ tree, item, itemId }) => tree.getState().focusedItem === itemId || tree.getState().focusedItem === null && item.getItemMeta().index === 0,
+    isFolder: ({ tree, item, itemId }) => itemId === tree.getConfig().rootItemId || tree.getConfig().isItemFolder(item),
+    getItemName: ({ tree, item }) => {
+      const config = tree.getConfig();
+      return config.getItemName(item);
+    },
+    setFocused: ({ tree, itemId }) => {
+      tree.applySubStateUpdate("focusedItem", itemId);
+    },
+    primaryAction: ({ tree, item }) => {
+      var _a, _b;
+      return (_b = (_a = tree.getConfig()).onPrimaryAction) == null ? undefined : _b.call(_a, item);
+    },
+    getParent: ({ tree, item }) => item.getItemMeta().parentId ? tree.getItemInstance(item.getItemMeta().parentId) : undefined,
+    getIndexInParent: ({ item }) => item.getItemMeta().posInSet,
+    getChildren: ({ tree, itemId }) => tree.retrieveChildrenIds(itemId).map((id) => tree.getItemInstance(id)),
+    getTree: ({ tree }) => tree,
+    getItemAbove: ({ tree, item }) => tree.getItems()[item.getItemMeta().index - 1],
+    getItemBelow: ({ tree, item }) => tree.getItems()[item.getItemMeta().index + 1]
+  },
+  hotkeys: {
+    focusNextItem: {
+      hotkey: "ArrowDown",
+      canRepeat: true,
+      preventDefault: true,
+      isEnabled: (tree) => {
+        var _a, _b;
+        return !((_b = (_a = tree.isSearchOpen) == null ? undefined : _a.call(tree)) != null ? _b : false) && !tree.getState().dnd;
+      },
+      handler: (e, tree) => {
+        tree.focusNextItem();
+        tree.updateDomFocus();
+      }
+    },
+    focusPreviousItem: {
+      hotkey: "ArrowUp",
+      canRepeat: true,
+      preventDefault: true,
+      isEnabled: (tree) => {
+        var _a, _b;
+        return !((_b = (_a = tree.isSearchOpen) == null ? undefined : _a.call(tree)) != null ? _b : false) && !tree.getState().dnd;
+      },
+      handler: (e, tree) => {
+        tree.focusPreviousItem();
+        tree.updateDomFocus();
+      }
+    },
+    expandOrDown: {
+      hotkey: "ArrowRight",
+      canRepeat: true,
+      handler: (e, tree) => {
+        const item = tree.getFocusedItem();
+        if (item.isExpanded() || !item.isFolder()) {
+          tree.focusNextItem();
+          tree.updateDomFocus();
+        } else {
+          item.expand();
+        }
+      }
+    },
+    collapseOrUp: {
+      hotkey: "ArrowLeft",
+      canRepeat: true,
+      handler: (e, tree) => {
+        var _a;
+        const item = tree.getFocusedItem();
+        if ((!item.isExpanded() || !item.isFolder()) && item.getItemMeta().level !== 0) {
+          (_a = item.getParent()) == null || _a.setFocused();
+          tree.updateDomFocus();
+        } else {
+          item.collapse();
+        }
+      }
+    },
+    focusFirstItem: {
+      hotkey: "Home",
+      handler: (e, tree) => {
+        var _a;
+        (_a = tree.getItems()[0]) == null || _a.setFocused();
+        tree.updateDomFocus();
+      }
+    },
+    focusLastItem: {
+      hotkey: "End",
+      handler: (e, tree) => {
+        var _a;
+        (_a = tree.getItems()[tree.getItems().length - 1]) == null || _a.setFocused();
+        tree.updateDomFocus();
+      }
+    }
+  }
+};
+var buildStaticInstance = (features, instanceType, buildOpts) => {
+  const instance = {};
+  const finalize = () => {
+    const opts = buildOpts(instance);
+    featureLoop:
+      for (let i = 0;i < features.length; i++) {
+        const definition = features[i][instanceType];
+        if (!definition)
+          continue featureLoop;
+        methodLoop:
+          for (const [key, method] of Object.entries(definition)) {
+            if (!method)
+              continue methodLoop;
+            const prev = instance[key];
+            instance[key] = (...args) => {
+              return method(__spreadProps2(__spreadValues2({}, opts), { prev }), ...args);
+            };
+          }
+      }
+  };
+  return [instance, finalize];
+};
+var verifyFeatures = (features) => {
+  var _a;
+  const loadedFeatures = features == null ? undefined : features.map((feature) => feature.key);
+  for (const feature of features != null ? features : []) {
+    const missingDependency = (_a = feature.deps) == null ? undefined : _a.find((dep) => !(loadedFeatures == null ? undefined : loadedFeatures.includes(dep)));
+    if (missingDependency) {
+      throw throwError(`${feature.key} needs ${missingDependency}`);
+    }
+  }
+};
+var exhaustiveSort = (arr, compareFn) => {
+  const n = arr.length;
+  for (let i = 0;i < n; i++) {
+    for (let j = i + 1;j < n; j++) {
+      if (compareFn(arr[j], arr[i]) < 0) {
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+      }
+    }
+  }
+  return arr;
+};
+var compareFeatures = (originalOrder) => (feature1, feature2) => {
+  var _a, _b;
+  if (feature2.key && ((_a = feature1.overwrites) == null ? undefined : _a.includes(feature2.key))) {
+    return 1;
+  }
+  if (feature1.key && ((_b = feature2.overwrites) == null ? undefined : _b.includes(feature1.key))) {
+    return -1;
+  }
+  return originalOrder.indexOf(feature1) - originalOrder.indexOf(feature2);
+};
+var sortFeatures = (features = []) => exhaustiveSort(features, compareFeatures(features));
+var createTree = (initialConfig) => {
+  var _a, _b, _c, _d;
+  const buildInstance = (_a = initialConfig.instanceBuilder) != null ? _a : buildStaticInstance;
+  const additionalFeatures = [
+    treeFeature,
+    ...sortFeatures(initialConfig.features)
+  ];
+  verifyFeatures(additionalFeatures);
+  const features = [...additionalFeatures];
+  const [treeInstance, finalizeTree] = buildInstance(features, "treeInstance", (tree) => ({ tree }));
+  let state = additionalFeatures.reduce((acc, feature) => {
+    var _a2, _b2;
+    return (_b2 = (_a2 = feature.getInitialState) == null ? undefined : _a2.call(feature, acc, treeInstance)) != null ? _b2 : acc;
+  }, (_c = (_b = initialConfig.initialState) != null ? _b : initialConfig.state) != null ? _c : {});
+  let config = additionalFeatures.reduce((acc, feature) => {
+    var _a2, _b2;
+    return (_b2 = (_a2 = feature.getDefaultConfig) == null ? undefined : _a2.call(feature, acc, treeInstance)) != null ? _b2 : acc;
+  }, initialConfig);
+  const stateHandlerNames = additionalFeatures.reduce((acc, feature) => __spreadValues2(__spreadValues2({}, acc), feature.stateHandlerNames), {});
+  let treeElement;
+  const treeDataRef = { current: {} };
+  let rebuildScheduled = false;
+  const itemInstancesMap = {};
+  let itemInstances = [];
+  const itemElementsMap = {};
+  const itemDataRefs = {};
+  let itemMetaMap = {};
+  const hotkeyPresets = {};
+  const rebuildItemMeta = () => {
+    itemInstances = [];
+    itemMetaMap = {};
+    const [rootInstance, finalizeRootInstance] = buildInstance(features, "itemInstance", (item) => ({ item, tree: treeInstance, itemId: config.rootItemId }));
+    finalizeRootInstance();
+    itemInstancesMap[config.rootItemId] = rootInstance;
+    itemMetaMap[config.rootItemId] = {
+      itemId: config.rootItemId,
+      index: -1,
+      parentId: null,
+      level: -1,
+      posInSet: 0,
+      setSize: 1
+    };
+    for (const item of treeInstance.getItemsMeta()) {
+      itemMetaMap[item.itemId] = item;
+      if (!itemInstancesMap[item.itemId]) {
+        const [instance, finalizeInstance] = buildInstance(features, "itemInstance", (instance2) => ({
+          item: instance2,
+          tree: treeInstance,
+          itemId: item.itemId
+        }));
+        finalizeInstance();
+        itemInstancesMap[item.itemId] = instance;
+        itemInstances.push(instance);
+      } else {
+        itemInstances.push(itemInstancesMap[item.itemId]);
+      }
+    }
+    rebuildScheduled = false;
+  };
+  const eachFeature = (fn) => {
+    for (const feature of additionalFeatures) {
+      fn(feature);
+    }
+  };
+  const mainFeature = {
+    key: "main",
+    treeInstance: {
+      getState: () => state,
+      setState: ({}, updater) => {
+        var _a2;
+        (_a2 = config.setState) == null || _a2.call(config, state);
+      },
+      setMounted: ({}, isMounted) => {
+        var _a2;
+        const ref = treeDataRef.current;
+        ref.isMounted = isMounted;
+        if (isMounted) {
+          (_a2 = ref.waitingForMount) == null || _a2.forEach((cb) => cb());
+          ref.waitingForMount = [];
+        }
+      },
+      applySubStateUpdate: ({}, stateName, updater) => {
+        var _a2;
+        const apply = () => {
+          state[stateName] = typeof updater === "function" ? updater(state[stateName]) : updater;
+          const externalStateSetter = config[stateHandlerNames[stateName]];
+          externalStateSetter == null || externalStateSetter(state[stateName]);
+        };
+        const ref = treeDataRef.current;
+        if (ref.isMounted) {
+          apply();
+        } else {
+          (_a2 = ref.waitingForMount) != null || (ref.waitingForMount = []);
+          ref.waitingForMount.push(apply);
+        }
+      },
+      rebuildTree: () => {
+        var _a2, _b2;
+        const ref = treeDataRef.current;
+        if (ref.isMounted) {
+          rebuildItemMeta();
+          (_a2 = config.setState) == null || _a2.call(config, state);
+        } else {
+          (_b2 = ref.waitingForMount) != null || (ref.waitingForMount = []);
+          ref.waitingForMount.push(() => {
+            var _a3;
+            rebuildItemMeta();
+            (_a3 = config.setState) == null || _a3.call(config, state);
+          });
+        }
+      },
+      scheduleRebuildTree: () => {
+        rebuildScheduled = true;
+      },
+      getConfig: () => config,
+      setConfig: (_, updater) => {
+        var _a2, _b2, _c2;
+        const newConfig = typeof updater === "function" ? updater(config) : updater;
+        const hasChangedExpandedItems = ((_a2 = newConfig.state) == null ? undefined : _a2.expandedItems) && ((_b2 = newConfig.state) == null ? undefined : _b2.expandedItems) !== state.expandedItems;
+        config = newConfig;
+        if (newConfig.state) {
+          state = __spreadValues2(__spreadValues2({}, state), newConfig.state);
+        }
+        if (hasChangedExpandedItems) {
+          rebuildItemMeta();
+          (_c2 = config.setState) == null || _c2.call(config, state);
+        }
+      },
+      getItemInstance: ({}, itemId) => {
+        const existingInstance = itemInstancesMap[itemId];
+        if (!existingInstance) {
+          const [instance, finalizeInstance] = buildInstance(features, "itemInstance", (instance2) => ({
+            item: instance2,
+            tree: treeInstance,
+            itemId
+          }));
+          finalizeInstance();
+          return instance;
+        }
+        return existingInstance;
+      },
+      getItems: () => {
+        if (rebuildScheduled)
+          rebuildItemMeta();
+        return itemInstances;
+      },
+      registerElement: ({}, element) => {
+        if (treeElement === element) {
+          return;
+        }
+        if (treeElement && !element) {
+          eachFeature((feature) => {
+            var _a2;
+            return (_a2 = feature.onTreeUnmount) == null ? undefined : _a2.call(feature, treeInstance, treeElement);
+          });
+        } else if (!treeElement && element) {
+          eachFeature((feature) => {
+            var _a2;
+            return (_a2 = feature.onTreeMount) == null ? undefined : _a2.call(feature, treeInstance, element);
+          });
+        }
+        treeElement = element;
+      },
+      getElement: () => treeElement,
+      getDataRef: () => treeDataRef,
+      getHotkeyPresets: () => hotkeyPresets
+    },
+    itemInstance: {
+      registerElement: ({ itemId, item }, element) => {
+        if (itemElementsMap[itemId] === element) {
+          return;
+        }
+        const oldElement = itemElementsMap[itemId];
+        if (oldElement && !element) {
+          eachFeature((feature) => {
+            var _a2;
+            return (_a2 = feature.onItemUnmount) == null ? undefined : _a2.call(feature, item, oldElement, treeInstance);
+          });
+        } else if (!oldElement && element) {
+          eachFeature((feature) => {
+            var _a2;
+            return (_a2 = feature.onItemMount) == null ? undefined : _a2.call(feature, item, element, treeInstance);
+          });
+        }
+        itemElementsMap[itemId] = element;
+      },
+      getElement: ({ itemId }) => itemElementsMap[itemId],
+      getDataRef: ({ itemId }) => {
+        var _a2;
+        return (_a2 = itemDataRefs[itemId]) != null ? _a2 : itemDataRefs[itemId] = { current: {} };
+      },
+      getItemMeta: ({ itemId }) => {
+        var _a2;
+        return (_a2 = itemMetaMap[itemId]) != null ? _a2 : {
+          itemId,
+          parentId: null,
+          level: -1,
+          index: -1,
+          posInSet: 0,
+          setSize: 1
+        };
+      }
+    }
+  };
+  features.unshift(mainFeature);
+  for (const feature of features) {
+    Object.assign(hotkeyPresets, (_d = feature.hotkeys) != null ? _d : {});
+  }
+  finalizeTree();
+  return treeInstance;
+};
+var AssistiveDndState = /* @__PURE__ */ ((AssistiveDndState2) => {
+  AssistiveDndState2[AssistiveDndState2["None"] = 0] = "None";
+  AssistiveDndState2[AssistiveDndState2["Started"] = 1] = "Started";
+  AssistiveDndState2[AssistiveDndState2["Dragging"] = 2] = "Dragging";
+  AssistiveDndState2[AssistiveDndState2["Completed"] = 3] = "Completed";
+  AssistiveDndState2[AssistiveDndState2["Aborted"] = 4] = "Aborted";
+  return AssistiveDndState2;
+})(AssistiveDndState || {});
+var selectionFeature = {
+  key: "selection",
+  getInitialState: (initialState) => __spreadValues2({
+    selectedItems: []
+  }, initialState),
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    setSelectedItems: makeStateUpdater("selectedItems", tree)
+  }, defaultConfig),
+  stateHandlerNames: {
+    selectedItems: "setSelectedItems"
+  },
+  treeInstance: {
+    setSelectedItems: ({ tree }, selectedItems) => {
+      tree.applySubStateUpdate("selectedItems", selectedItems);
+    },
+    getSelectedItems: ({ tree }) => {
+      return tree.getState().selectedItems.map(tree.getItemInstance);
+    }
+  },
+  itemInstance: {
+    select: ({ tree, itemId }) => {
+      const { selectedItems } = tree.getState();
+      tree.setSelectedItems(selectedItems.includes(itemId) ? selectedItems : [...selectedItems, itemId]);
+    },
+    deselect: ({ tree, itemId }) => {
+      const { selectedItems } = tree.getState();
+      tree.setSelectedItems(selectedItems.filter((id) => id !== itemId));
+    },
+    isSelected: ({ tree, itemId }) => {
+      const { selectedItems } = tree.getState();
+      return selectedItems.includes(itemId);
+    },
+    selectUpTo: ({ tree, item, itemId }, ctrl) => {
+      const indexA = item.getItemMeta().index;
+      const dataRef = tree.getDataRef();
+      if (!dataRef.current.selectUpToAnchorId) {
+        dataRef.current.selectUpToAnchorId = itemId;
+        tree.setSelectedItems([itemId]);
+        return;
+      }
+      const itemB = tree.getItemInstance(dataRef.current.selectUpToAnchorId);
+      const indexB = itemB.getItemMeta().index;
+      const [a, b] = indexA < indexB ? [indexA, indexB] : [indexB, indexA];
+      const newSelectedItems = tree.getItems().slice(a, b + 1).map((treeItem) => treeItem.getItemMeta().itemId);
+      if (!ctrl) {
+        tree.setSelectedItems(newSelectedItems);
+        return;
+      }
+      const { selectedItems } = tree.getState();
+      const uniqueSelectedItems = [
+        .../* @__PURE__ */ new Set([...selectedItems, ...newSelectedItems])
+      ];
+      tree.setSelectedItems(uniqueSelectedItems);
+    },
+    toggleSelect: ({ item }) => {
+      if (item.isSelected()) {
+        item.deselect();
+      } else {
+        item.select();
+      }
+    },
+    getProps: ({ tree, item, itemId, prev }) => __spreadProps2(__spreadValues2({}, prev == null ? undefined : prev()), {
+      "aria-selected": item.isSelected() ? "true" : "false",
+      onClick: (e) => {
+        var _a, _b;
+        if (e.shiftKey) {
+          item.selectUpTo(e.ctrlKey || e.metaKey);
+        } else if (e.ctrlKey || e.metaKey) {
+          item.toggleSelect();
+        } else {
+          tree.setSelectedItems([itemId]);
+        }
+        if (!e.shiftKey) {
+          tree.getDataRef().current.selectUpToAnchorId = itemId;
+        }
+        (_b = (_a = prev == null ? undefined : prev()) == null ? undefined : _a.onClick) == null || _b.call(_a, e);
+      }
+    })
+  },
+  hotkeys: {
+    toggleSelectedItem: {
+      hotkey: "Control+Space",
+      preventDefault: true,
+      handler: (_, tree) => {
+        tree.getFocusedItem().toggleSelect();
+      }
+    },
+    selectUpwards: {
+      hotkey: "Shift+ArrowUp",
+      handler: (e, tree) => {
+        const focused = tree.getFocusedItem();
+        const above = focused.getItemAbove();
+        if (!above)
+          return;
+        if (focused.isSelected() && above.isSelected()) {
+          focused.deselect();
+        } else {
+          above.select();
+        }
+        above.setFocused();
+        tree.updateDomFocus();
+      }
+    },
+    selectDownwards: {
+      hotkey: "Shift+ArrowDown",
+      handler: (e, tree) => {
+        const focused = tree.getFocusedItem();
+        const below = focused.getItemBelow();
+        if (!below)
+          return;
+        if (focused.isSelected() && below.isSelected()) {
+          focused.deselect();
+        } else {
+          below.select();
+        }
+        below.setFocused();
+        tree.updateDomFocus();
+      }
+    },
+    selectAll: {
+      hotkey: "Control+KeyA",
+      preventDefault: true,
+      handler: (e, tree) => {
+        tree.setSelectedItems(tree.getItems().map((item) => item.getId()));
+      }
+    }
+  }
+};
+var getAllLoadedDescendants = (tree, itemId, includeFolders = false) => {
+  if (!tree.getConfig().isItemFolder(tree.getItemInstance(itemId))) {
+    return [itemId];
+  }
+  const descendants = tree.retrieveChildrenIds(itemId, true).map((child) => getAllLoadedDescendants(tree, child, includeFolders)).flat();
+  return includeFolders ? [itemId, ...descendants] : descendants;
+};
+var getAllDescendants = (tree, itemId, includeFolders = false) => __async(null, null, function* () {
+  const item = tree.getItemInstance(itemId);
+  if (!item.hasLoadedData()) {
+    yield tree.loadItemData(itemId);
+  }
+  if (!tree.getConfig().isItemFolder(item)) {
+    return [itemId];
+  }
+  const childrenIds = yield tree.loadChildrenIds(itemId);
+  const descendants = (yield Promise.all(childrenIds.map((child) => getAllDescendants(tree, child, includeFolders)))).flat();
+  return includeFolders ? [itemId, ...descendants] : descendants;
+});
+var withLoadingState = (tree, itemId, callback) => __async(null, null, function* () {
+  const prom = callback();
+  const immediate = {};
+  const firstCompleted = yield Promise.race([prom, immediate]);
+  if (firstCompleted !== immediate) {
+    tree.applySubStateUpdate("loadingCheckPropagationItems", (items) => [
+      ...items,
+      itemId
+    ]);
+    try {
+      yield prom;
+    } finally {
+      tree.applySubStateUpdate("loadingCheckPropagationItems", (items) => items.filter((id) => id !== itemId));
+    }
+  } else {
+    yield prom;
+  }
+});
+var checkboxesFeature = {
+  key: "checkboxes",
+  overwrites: ["selection"],
+  getInitialState: (initialState) => __spreadValues2({
+    checkedItems: [],
+    loadingCheckPropagationItems: []
+  }, initialState),
+  getDefaultConfig: (defaultConfig, tree) => {
+    var _a, _b;
+    const propagateCheckedState = (_a = defaultConfig.propagateCheckedState) != null ? _a : true;
+    const canCheckFolders = (_b = defaultConfig.canCheckFolders) != null ? _b : !propagateCheckedState;
+    return __spreadValues2({
+      setCheckedItems: makeStateUpdater("checkedItems", tree),
+      setLoadingCheckPropagationItems: makeStateUpdater("loadingCheckPropagationItems", tree),
+      propagateCheckedState,
+      canCheckFolders
+    }, defaultConfig);
+  },
+  stateHandlerNames: {
+    checkedItems: "setCheckedItems",
+    loadingCheckPropagationItems: "setLoadingCheckPropagationItems"
+  },
+  treeInstance: {
+    setCheckedItems: ({ tree }, checkedItems) => {
+      tree.applySubStateUpdate("checkedItems", checkedItems);
+    }
+  },
+  itemInstance: {
+    getCheckboxProps: ({ item }) => {
+      const checkedState = item.getCheckedState();
+      return {
+        onChange: item.toggleCheckedState,
+        checked: checkedState === "checked",
+        ref: (r) => {
+          if (r) {
+            r.indeterminate = checkedState === "indeterminate";
+          }
+        }
+      };
+    },
+    toggleCheckedState: (_0) => __async(null, [_0], function* ({ item }) {
+      if (item.getCheckedState() === "checked") {
+        yield item.setUnchecked();
+      } else {
+        yield item.setChecked();
+      }
+    }),
+    getCheckedState: ({ item, tree }) => {
+      const { checkedItems } = tree.getState();
+      const { propagateCheckedState } = tree.getConfig();
+      const itemId = item.getId();
+      if (checkedItems.includes(itemId)) {
+        return "checked";
+      }
+      if (item.isFolder() && propagateCheckedState) {
+        const descendants = getAllLoadedDescendants(tree, itemId);
+        if (descendants.length === 0)
+          return "unchecked";
+        if (descendants.every((d) => checkedItems.includes(d))) {
+          return "checked";
+        }
+        if (descendants.some((d) => checkedItems.includes(d))) {
+          return "indeterminate";
+        }
+      }
+      return "unchecked";
+    },
+    setChecked: (_0) => __async(null, [_0], function* ({ item, tree, itemId }) {
+      yield withLoadingState(tree, itemId, () => __async(null, null, function* () {
+        const { propagateCheckedState, canCheckFolders } = tree.getConfig();
+        if (item.isFolder() && propagateCheckedState) {
+          const descendants = yield getAllDescendants(tree, itemId, canCheckFolders);
+          tree.applySubStateUpdate("checkedItems", (items) => [
+            ...items,
+            ...descendants
+          ]);
+        } else if (!item.isFolder() || canCheckFolders) {
+          tree.applySubStateUpdate("checkedItems", (items) => [
+            ...items,
+            itemId
+          ]);
+        }
+      }));
+    }),
+    setUnchecked: (_0) => __async(null, [_0], function* ({ item, tree, itemId }) {
+      yield withLoadingState(tree, itemId, () => __async(null, null, function* () {
+        const { propagateCheckedState, canCheckFolders } = tree.getConfig();
+        if (item.isFolder() && propagateCheckedState) {
+          const descendants = yield getAllDescendants(tree, itemId, canCheckFolders);
+          tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => !descendants.includes(id) && id !== itemId));
+        } else {
+          tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => id !== itemId));
+        }
+      }));
+    })
+  }
+};
+var resolveKeyCode = (event) => event.code !== "" && event.code !== "Unidentified" ? event.code : event.key;
+var specialKeys = {
+  letter: /^Key[A-Z]$/,
+  letterornumber: /^(Key[A-Z]|Digit[0-9])$/,
+  plus: /^(NumpadAdd|Plus)$/,
+  minus: /^(NumpadSubtract|Minus)$/,
+  control: /^(ControlLeft|ControlRight)$/,
+  shift: /^(ShiftLeft|ShiftRight)$/,
+  metaorcontrol: /^(MetaLeft|MetaRight|ControlLeft|ControlRight)$/,
+  enter: /^(Enter|NumpadEnter)$/
+};
+var modifierKeyCodes = /* @__PURE__ */ new Set([
+  "MetaLeft",
+  "MetaRight",
+  "Meta",
+  "ControlLeft",
+  "ControlRight",
+  "Control",
+  "AltLeft",
+  "AltRight",
+  "Alt",
+  "ShiftLeft",
+  "ShiftRight",
+  "Shift"
+]);
+var testHotkeyMatch = (pressedKeys, tree, hotkey) => {
+  const supposedKeys = hotkey.hotkey.toLowerCase().split("+");
+  const doKeysMatch = supposedKeys.every((key) => {
+    if (key in specialKeys) {
+      return [...pressedKeys].some((pressedKey) => specialKeys[key].test(pressedKey));
+    }
+    const pressedKeysLowerCase = [...pressedKeys].map((pressedKey) => pressedKey.toLowerCase());
+    return pressedKeysLowerCase.includes(key.toLowerCase()) || pressedKeysLowerCase.includes(`key${key.toLowerCase()}`);
+  });
+  const isEnabled = !hotkey.isEnabled || hotkey.isEnabled(tree);
+  return doKeysMatch && isEnabled && pressedKeys.size === supposedKeys.length;
+};
+var findHotkeyMatch = (pressedKeys, tree, config1, config2) => {
+  var _a;
+  return (_a = Object.entries(__spreadValues2(__spreadValues2({}, config1), config2)).find(([, hotkey]) => testHotkeyMatch(pressedKeys, tree, hotkey))) == null ? undefined : _a[0];
+};
+var hotkeysCoreController = {
+  clearPressedKeys: (dataRef) => {
+    dataRef.current.pressedKeys = /* @__PURE__ */ new Set;
+  },
+  dispatchKeyDown: (tree, dataRef, eventLike, options = {}) => {
+    if (eventLike.defaultPrevented)
+      return;
+    var _a, _b, _c, _d, _e;
+    const { isInputFocused = false, releaseAfterDispatch = false } = options;
+    const { ignoreHotkeysOnInputs, onTreeHotkey, hotkeys } = tree.getConfig();
+    if (isInputFocused && ignoreHotkeysOnInputs) {
+      return;
+    }
+    const resolvedCode = resolveKeyCode({
+      code: (_a = eventLike.code) != null ? _a : "",
+      key: (_b = eventLike.key) != null ? _b : ""
+    });
+    (_d = (_c = dataRef.current).pressedKeys) != null || (_c.pressedKeys = /* @__PURE__ */ new Set);
+    const isNewKey = !dataRef.current.pressedKeys.has(resolvedCode);
+    for (const [flag, codes] of [
+      ["ctrlKey", ["ControlLeft", "ControlRight", "Control"]],
+      ["shiftKey", ["ShiftLeft", "ShiftRight", "Shift"]],
+      ["altKey", ["AltLeft", "AltRight", "Alt"]],
+      ["metaKey", ["MetaLeft", "MetaRight", "Meta"]]
+    ]) {
+      if (eventLike[flag] === false) {
+        for (const code of codes)
+          dataRef.current.pressedKeys.delete(code);
+      } else if (eventLike[flag] === true && !codes.some((code) => dataRef.current.pressedKeys.has(code))) {
+        dataRef.current.pressedKeys.add(codes.some((code) => code === resolvedCode) ? resolvedCode : codes[0]);
+      }
+    }
+    if (resolvedCode) {
+      dataRef.current.pressedKeys.add(resolvedCode);
+    }
+    const hotkeyName = findHotkeyMatch(dataRef.current.pressedKeys, tree, tree.getHotkeyPresets(), hotkeys);
+    if (releaseAfterDispatch && resolvedCode) {
+      dataRef.current.pressedKeys.delete(resolvedCode);
+    }
+    if (!hotkeyName) {
+      return;
+    }
+    const hotkeyConfig = __spreadValues2(__spreadValues2({}, tree.getHotkeyPresets()[hotkeyName]), hotkeys == null ? undefined : hotkeys[hotkeyName]);
+    if (!hotkeyConfig) {
+      return;
+    }
+    if (!hotkeyConfig.allowWhenInputFocused && isInputFocused) {
+      return;
+    }
+    if (!hotkeyConfig.canRepeat && !isNewKey) {
+      return;
+    }
+    if (hotkeyConfig.preventDefault) {
+      (_e = eventLike.preventDefault) == null || _e.call(eventLike);
+    }
+    hotkeyConfig.handler(eventLike, tree);
+    onTreeHotkey == null || onTreeHotkey(hotkeyName, eventLike);
+  },
+  dispatchKeyUp: (dataRef, eventLike) => {
+    var _a, _b, _c, _d;
+    const resolvedCode = resolveKeyCode({
+      code: (_a = eventLike.code) != null ? _a : "",
+      key: (_b = eventLike.key) != null ? _b : ""
+    });
+    if (!resolvedCode) {
+      return;
+    }
+    (_d = (_c = dataRef.current).pressedKeys) != null || (_c.pressedKeys = /* @__PURE__ */ new Set);
+    if (modifierKeyCodes.has(resolvedCode)) {
+      dataRef.current.pressedKeys = new Set([...dataRef.current.pressedKeys].filter((pressedKey) => modifierKeyCodes.has(pressedKey)));
+    }
+    dataRef.current.pressedKeys.delete(resolvedCode);
+  }
+};
+var hotkeysCoreFeature = {
+  key: "hotkeys-core",
+  onTreeMount: (tree, element) => {
+    const data = tree.getDataRef();
+    const keydown = (e) => {
+      if (e.defaultPrevented)
+        return;
+      const path = e.composedPath();
+      const owner = path.find((node) => node instanceof Element && node.getAttribute("role") === "tree");
+      if (owner && owner !== element)
+        return;
+      let isInputFocused = false;
+      for (const node of path) {
+        if (node === element)
+          break;
+        if (!(node instanceof Element))
+          continue;
+        if (node.matches("input, textarea, select") || node instanceof HTMLElement && node.isContentEditable) {
+          isInputFocused = true;
+          break;
+        }
+        if (node.getAttribute("role") === "treeitem")
+          break;
+        if (node.matches('button, a, summary, audio[controls], video[controls], [tabindex], [role="button"], [role="link"], [role="menu"], [role="menuitem"], [role="menuitemcheckbox"], [role="menuitemradio"], [role="textbox"], [role="combobox"], [role="listbox"], [role="option"], [role="slider"], [role="spinbutton"], [role="checkbox"], [role="radio"], [role="switch"], [role="tab"]'))
+          return;
+      }
+      hotkeysCoreController.dispatchKeyDown(tree, data, e, {
+        isInputFocused,
+        releaseAfterDispatch: isInputFocused
+      });
+    };
+    const keyup = (e) => {
+      hotkeysCoreController.dispatchKeyUp(data, e);
+    };
+    const reset = () => {
+      hotkeysCoreController.clearPressedKeys(data);
+    };
+    element.addEventListener("keydown", keydown);
+    document.addEventListener("keyup", keyup);
+    window.addEventListener("focus", reset);
+    data.current.keydownHandler = keydown;
+    data.current.keyupHandler = keyup;
+    data.current.resetHandler = reset;
+  },
+  onTreeUnmount: (tree, element) => {
+    const data = tree.getDataRef();
+    if (data.current.keyupHandler) {
+      document.removeEventListener("keyup", data.current.keyupHandler);
+      delete data.current.keyupHandler;
+    }
+    if (data.current.keydownHandler) {
+      element.removeEventListener("keydown", data.current.keydownHandler);
+      delete data.current.keydownHandler;
+    }
+    if (data.current.resetHandler) {
+      window.removeEventListener("focus", data.current.resetHandler);
+      delete data.current.resetHandler;
+    }
+  }
+};
+var getDataRef = (tree) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const dataRef = tree.getDataRef();
+  (_b = (_a = dataRef.current).itemData) != null || (_a.itemData = {});
+  (_d = (_c = dataRef.current).childrenIds) != null || (_c.childrenIds = {});
+  (_f = (_e = dataRef.current).loadingDataSubs) != null || (_e.loadingDataSubs = {});
+  (_h = (_g = dataRef.current).loadingChildrenSubs) != null || (_g.loadingChildrenSubs = {});
+  return dataRef;
+};
+var loadItemData = (tree, itemId) => __async(null, null, function* () {
+  var _a, _b;
+  const config = tree.getConfig();
+  const dataRef = getDataRef(tree);
+  if (tree.getState().loadingItemData.includes(itemId)) {
+    return new Promise((resolve) => {
+      var _a2, _b2;
+      (_b2 = (_a2 = dataRef.current.loadingDataSubs)[itemId]) != null || (_a2[itemId] = []);
+      dataRef.current.loadingDataSubs[itemId].push(() => {
+        resolve(dataRef.current.itemData[itemId]);
+      });
+    });
+  }
+  if (!dataRef.current.itemData[itemId]) {
+    tree.applySubStateUpdate("loadingItemData", (loadingItemData) => [
+      ...loadingItemData,
+      itemId
+    ]);
+  }
+  const item = yield config.dataLoader.getItem(itemId);
+  dataRef.current.itemData[itemId] = item;
+  (_a = config.onLoadedItem) == null || _a.call(config, itemId, item);
+  tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => id !== itemId));
+  (_b = dataRef.current.loadingDataSubs[itemId]) == null || _b.forEach((cb) => cb());
+  return item;
+});
+var loadChildrenIds = (tree, itemId) => __async(null, null, function* () {
+  var _a, _b, _c;
+  const config = tree.getConfig();
+  const dataRef = getDataRef(tree);
+  let childrenIds;
+  if (tree.getState().loadingItemChildrens.includes(itemId)) {
+    return new Promise((resolve) => {
+      var _a2, _b2;
+      (_b2 = (_a2 = dataRef.current.loadingChildrenSubs)[itemId]) != null || (_a2[itemId] = []);
+      dataRef.current.loadingChildrenSubs[itemId].push(() => {
+        resolve(dataRef.current.childrenIds[itemId]);
+      });
+    });
+  }
+  if (!dataRef.current.childrenIds[itemId]) {
+    tree.applySubStateUpdate("loadingItemChildrens", (loadingItemChildrens) => [
+      ...loadingItemChildrens,
+      itemId
+    ]);
+  }
+  if ("getChildrenWithData" in config.dataLoader) {
+    const children = yield config.dataLoader.getChildrenWithData(itemId);
+    childrenIds = children.map((c) => c.id);
+    dataRef.current.childrenIds[itemId] = childrenIds;
+    children.forEach(({ id, data }) => {
+      var _a2;
+      dataRef.current.itemData[id] = data;
+      (_a2 = config.onLoadedItem) == null || _a2.call(config, id, data);
+    });
+    (_a = config.onLoadedChildren) == null || _a.call(config, itemId, childrenIds);
+    tree.rebuildTree();
+    tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => !childrenIds.includes(id)));
+  } else {
+    childrenIds = yield config.dataLoader.getChildren(itemId);
+    dataRef.current.childrenIds[itemId] = childrenIds;
+    (_b = config.onLoadedChildren) == null || _b.call(config, itemId, childrenIds);
+    tree.rebuildTree();
+  }
+  tree.applySubStateUpdate("loadingItemChildrens", (loadingItemChildrens) => loadingItemChildrens.filter((id) => id !== itemId));
+  (_c = dataRef.current.loadingChildrenSubs[itemId]) == null || _c.forEach((cb) => cb());
+  return childrenIds;
+});
+var asyncDataLoaderFeature = {
+  key: "async-data-loader",
+  getInitialState: (initialState) => __spreadValues2({
+    loadingItemData: [],
+    loadingItemChildrens: []
+  }, initialState),
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    setLoadingItemData: makeStateUpdater("loadingItemData", tree),
+    setLoadingItemChildrens: makeStateUpdater("loadingItemChildrens", tree)
+  }, defaultConfig),
+  stateHandlerNames: {
+    loadingItemData: "setLoadingItemData",
+    loadingItemChildrens: "setLoadingItemChildrens"
+  },
+  treeInstance: {
+    waitForItemDataLoaded: ({ tree }, itemId) => tree.loadItemData(itemId),
+    waitForItemChildrenLoaded: ({ tree }, itemId) => tree.loadChildrenIds(itemId),
+    loadItemData: (_0, _1) => __async(null, [_0, _1], function* ({ tree }, itemId) {
+      var _a;
+      return (_a = getDataRef(tree).current.itemData[itemId]) != null ? _a : yield loadItemData(tree, itemId);
+    }),
+    loadChildrenIds: (_0, _1) => __async(null, [_0, _1], function* ({ tree }, itemId) {
+      var _a;
+      return (_a = getDataRef(tree).current.childrenIds[itemId]) != null ? _a : yield loadChildrenIds(tree, itemId);
+    }),
+    retrieveItemData: ({ tree }, itemId, skipFetch = false) => {
+      var _a, _b;
+      const config = tree.getConfig();
+      const dataRef = getDataRef(tree);
+      if (dataRef.current.itemData[itemId]) {
+        return dataRef.current.itemData[itemId];
+      }
+      if (!tree.getState().loadingItemData.includes(itemId) && !skipFetch) {
+        setTimeout(() => loadItemData(tree, itemId));
+      }
+      return (_b = (_a = config.createLoadingItemData) == null ? undefined : _a.call(config)) != null ? _b : null;
+    },
+    retrieveChildrenIds: ({ tree }, itemId, skipFetch = false) => {
+      const dataRef = getDataRef(tree);
+      if (dataRef.current.childrenIds[itemId]) {
+        return dataRef.current.childrenIds[itemId];
+      }
+      if (tree.getState().loadingItemChildrens.includes(itemId) || skipFetch) {
+        return [];
+      }
+      setTimeout(() => loadChildrenIds(tree, itemId));
+      return [];
+    }
+  },
+  itemInstance: {
+    isLoading: ({ tree, item }) => tree.getState().loadingItemData.includes(item.getItemMeta().itemId) || tree.getState().loadingItemChildrens.includes(item.getItemMeta().itemId),
+    invalidateItemData: (_0, _1) => __async(null, [_0, _1], function* ({ tree, itemId }, optimistic) {
+      var _a;
+      if (!optimistic) {
+        (_a = getDataRef(tree).current.itemData) == null || delete _a[itemId];
+      }
+      yield loadItemData(tree, itemId);
+    }),
+    invalidateChildrenIds: (_0, _1) => __async(null, [_0, _1], function* ({ tree, itemId }, optimistic) {
+      var _a;
+      if (!optimistic) {
+        (_a = getDataRef(tree).current.childrenIds) == null || delete _a[itemId];
+      }
+      yield loadChildrenIds(tree, itemId);
+    }),
+    updateCachedChildrenIds: ({ tree, itemId }, childrenIds, skipUpdateTree) => {
+      getDataRef(tree).current.childrenIds[itemId] = childrenIds;
+      if (!skipUpdateTree) {
+        tree.rebuildTree();
+      }
+    },
+    updateCachedData: ({ tree, itemId }, data, skipUpdateTree) => {
+      getDataRef(tree).current.itemData[itemId] = data;
+      if (!skipUpdateTree) {
+        tree.rebuildTree();
+      }
+    },
+    hasLoadedData: ({ tree, itemId }) => {
+      const dataRef = tree.getDataRef();
+      return dataRef.current.itemData[itemId] !== undefined;
+    }
+  }
+};
+var undefErrorMessage = "sync dataLoader returned undefined";
+var promiseErrorMessage = "sync dataLoader returned promise";
+var unpromise = (data) => {
+  if (!data) {
+    throw throwError(undefErrorMessage);
+  }
+  if (typeof data === "object" && "then" in data) {
+    throw throwError(promiseErrorMessage);
+  }
+  return data;
+};
+var syncDataLoaderFeature = {
+  key: "sync-data-loader",
+  getInitialState: (initialState) => __spreadValues2({
+    loadingItemData: [],
+    loadingItemChildrens: []
+  }, initialState),
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    setLoadingItemData: makeStateUpdater("loadingItemData", tree),
+    setLoadingItemChildrens: makeStateUpdater("loadingItemChildrens", tree)
+  }, defaultConfig),
+  stateHandlerNames: {
+    loadingItemData: "setLoadingItemData",
+    loadingItemChildrens: "setLoadingItemChildrens"
+  },
+  treeInstance: {
+    waitForItemDataLoaded: () => __async(null, null, function* () {}),
+    waitForItemChildrenLoaded: () => __async(null, null, function* () {}),
+    retrieveItemData: ({ tree }, itemId) => {
+      return unpromise(tree.getConfig().dataLoader.getItem(itemId));
+    },
+    retrieveChildrenIds: ({ tree }, itemId) => {
+      const { dataLoader } = tree.getConfig();
+      if ("getChildren" in dataLoader) {
+        return unpromise(dataLoader.getChildren(itemId));
+      }
+      return unpromise(dataLoader.getChildrenWithData(itemId)).map((c) => c.data);
+    },
+    loadItemData: ({ tree }, itemId) => tree.retrieveItemData(itemId),
+    loadChildrenIds: ({ tree }, itemId) => tree.retrieveChildrenIds(itemId)
+  },
+  itemInstance: {
+    isLoading: () => false,
+    hasLoadedData: () => true
+  }
+};
+var isOrderedDragTarget = (dragTarget) => ("childIndex" in dragTarget);
+var canDrop = (dataTransfer, target, tree) => {
+  var _a, _b, _c;
+  const draggedItems = (_a = tree.getState().dnd) == null ? undefined : _a.draggedItems;
+  const config = tree.getConfig();
+  if (draggedItems && !((_c = (_b = config.canDrop) == null ? undefined : _b.call(config, draggedItems, target)) != null ? _c : true)) {
+    return false;
+  }
+  if (draggedItems && draggedItems.some((draggedItem) => target.item.getId() === draggedItem.getId() || target.item.isDescendentOf(draggedItem.getId()))) {
+    return false;
+  }
+  if (!draggedItems && dataTransfer && config.canDropForeignDragObject && !config.canDropForeignDragObject(dataTransfer, target)) {
+    return false;
+  }
+  return true;
+};
+var getItemDropCategory = (item) => {
+  if (item.isExpanded()) {
+    return 1;
+  }
+  const parent = item.getParent();
+  if (parent && item.getIndexInParent() === item.getItemMeta().setSize - 1) {
+    return 2;
+  }
+  return 0;
+};
+var getInsertionIndex = (children, childIndex, draggedItems) => {
+  var _a;
+  const numberOfDragItemsBeforeTarget = (_a = children.slice(0, childIndex).reduce((counter, child) => child && (draggedItems == null ? undefined : draggedItems.some((i) => i.getId() === child.getId())) ? ++counter : counter, 0)) != null ? _a : 0;
+  return childIndex - numberOfDragItemsBeforeTarget;
+};
+var getTargetPlacement = (e, item, tree, canMakeChild) => {
+  var _a, _b, _c, _d, _e;
+  const config = tree.getConfig();
+  if (!config.canReorder) {
+    return canMakeChild ? { type: 2 } : { type: 1 };
+  }
+  const bb = (_a = item.getElement()) == null ? undefined : _a.getBoundingClientRect();
+  const topPercent = bb ? (e.clientY - bb.top) / bb.height : 0.5;
+  const leftPixels = bb ? e.clientX - bb.left : 0;
+  const targetDropCategory = getItemDropCategory(item);
+  const reorderAreaPercentage = !canMakeChild ? 0.5 : (_b = config.reorderAreaPercentage) != null ? _b : 0.3;
+  const indent = (_c = config.indent) != null ? _c : 20;
+  const makeChildType = canMakeChild ? 2 : 1;
+  if (targetDropCategory === 1) {
+    if (topPercent < reorderAreaPercentage) {
+      return { type: 0 };
+    }
+    return { type: makeChildType };
+  }
+  if (targetDropCategory === 2) {
+    if (leftPixels < item.getItemMeta().level * indent) {
+      if (topPercent < 0.5) {
+        return { type: 0 };
+      }
+      const minLevel = (_e = (_d = item.getItemBelow()) == null ? undefined : _d.getItemMeta().level) != null ? _e : 0;
+      return {
+        type: 3,
+        reparentLevel: Math.max(minLevel, Math.floor(leftPixels / indent))
+      };
+    }
+  }
+  if (topPercent < reorderAreaPercentage) {
+    return { type: 0 };
+  }
+  if (topPercent > 1 - reorderAreaPercentage) {
+    return { type: 1 };
+  }
+  return { type: makeChildType };
+};
+var getDragCode = (item, placement) => {
+  return [
+    item.getId(),
+    placement.type,
+    placement.type === 3 ? placement.reparentLevel : 0
+  ].join("__");
+};
+var getNthParent = (item, n) => {
+  if (n === item.getItemMeta().level) {
+    return item;
+  }
+  return getNthParent(item.getParent(), n);
+};
+var getReparentTarget = (item, reparentLevel, draggedItems) => {
+  const itemMeta = item.getItemMeta();
+  const reparentedTarget = getNthParent(item, reparentLevel - 1);
+  const targetItemAbove = getNthParent(item, reparentLevel);
+  const targetIndex = targetItemAbove.getIndexInParent() + 1;
+  return {
+    item: reparentedTarget,
+    childIndex: targetIndex,
+    insertionIndex: getInsertionIndex(reparentedTarget.getChildren(), targetIndex, draggedItems),
+    dragLineIndex: itemMeta.index + 1,
+    dragLineLevel: reparentLevel
+  };
+};
+var getDragTarget = (e, item, tree, hasDataTransferPayload, canReorder = tree.getConfig().canReorder) => {
+  var _a;
+  const dataTransfer = hasDataTransferPayload ? e.dataTransfer : null;
+  const draggedItems = (_a = tree.getState().dnd) == null ? undefined : _a.draggedItems;
+  const itemMeta = item.getItemMeta();
+  const parent = item.getParent();
+  const itemTarget = { item };
+  const parentTarget = parent ? { item: parent } : null;
+  const canBecomeSibling = parentTarget && canDrop(dataTransfer, parentTarget, tree);
+  const canMakeChild = canDrop(dataTransfer, itemTarget, tree);
+  const placement = getTargetPlacement(e, item, tree, canMakeChild);
+  if (!canReorder && parent && canBecomeSibling && placement.type !== 2) {
+    if (draggedItems == null ? undefined : draggedItems.some((item2) => item2.isDescendentOf(parent.getId()))) {
+      return itemTarget;
+    }
+    return parentTarget;
+  }
+  if (placement.type === 2) {
+    return itemTarget;
+  }
+  if (!canReorder && parent && !canBecomeSibling) {
+    return getDragTarget(e, parent, tree, hasDataTransferPayload, false);
+  }
+  if (!parent) {
+    return itemTarget;
+  }
+  if (!canBecomeSibling) {
+    return getDragTarget(e, parent, tree, hasDataTransferPayload, false);
+  }
+  if (placement.type === 3) {
+    return getReparentTarget(item, placement.reparentLevel, draggedItems);
+  }
+  const maybeAddOneForBelow = placement.type === 0 ? 0 : 1;
+  const childIndex = item.getIndexInParent() + maybeAddOneForBelow;
+  return {
+    item: parent,
+    dragLineIndex: itemMeta.index + maybeAddOneForBelow,
+    dragLineLevel: itemMeta.level,
+    childIndex,
+    insertionIndex: getInsertionIndex(parent.getChildren(), childIndex, draggedItems)
+  };
+};
+var handleAutoOpenFolder = (dataRef, tree, item, placement) => {
+  const { openOnDropDelay } = tree.getConfig();
+  const dragCode = dataRef.current.lastDragCode;
+  if (!openOnDropDelay || !item.isFolder() || item.isExpanded() || placement.type !== 2) {
+    return;
+  }
+  clearTimeout(dataRef.current.autoExpandTimeout);
+  dataRef.current.autoExpandTimeout = setTimeout(() => {
+    if (dragCode !== dataRef.current.lastDragCode || !dataRef.current.lastAllowDrop)
+      return;
+    item.expand();
+  }, openOnDropDelay);
+};
+var defaultCanDropForeignDragObject = () => false;
+var dragAndDropFeature = {
+  key: "drag-and-drop",
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    canDrop: (_, target) => target.item.isFolder(),
+    canDropForeignDragObject: defaultCanDropForeignDragObject,
+    canDragForeignDragObjectOver: defaultConfig.canDropForeignDragObject !== defaultCanDropForeignDragObject ? (dataTransfer) => dataTransfer.effectAllowed !== "none" : () => false,
+    setDndState: makeStateUpdater("dnd", tree),
+    canReorder: true,
+    openOnDropDelay: 800,
+    draggedItemOverwritesSelection: true
+  }, defaultConfig),
+  stateHandlerNames: {
+    dnd: "setDndState"
+  },
+  onTreeMount: (tree) => {
+    const listener = () => {
+      tree.applySubStateUpdate("dnd", null);
+    };
+    tree.getDataRef().current.windowDragEndListener = listener;
+    window.addEventListener("dragend", listener);
+  },
+  onTreeUnmount: (tree) => {
+    const { windowDragEndListener } = tree.getDataRef().current;
+    if (!windowDragEndListener)
+      return;
+    window.removeEventListener("dragend", windowDragEndListener);
+  },
+  treeInstance: {
+    getDragTarget: ({ tree }) => {
+      var _a, _b;
+      return (_b = (_a = tree.getState().dnd) == null ? undefined : _a.dragTarget) != null ? _b : null;
+    },
+    getDragLineData: ({ tree }) => {
+      var _a, _b, _c, _d, _e, _f;
+      const target = tree.getDragTarget();
+      const indent = ((_a = target == null ? undefined : target.item.getItemMeta().level) != null ? _a : 0) + 1;
+      const treeBb = (_b = tree.getElement()) == null ? undefined : _b.getBoundingClientRect();
+      if (!target || !treeBb || !isOrderedDragTarget(target))
+        return null;
+      const leftOffset = target.dragLineLevel * ((_c = tree.getConfig().indent) != null ? _c : 1);
+      const targetItem = tree.getItems()[target.dragLineIndex];
+      if (!targetItem) {
+        const bb2 = (_e = (_d = tree.getItems()[target.dragLineIndex - 1]) == null ? undefined : _d.getElement()) == null ? undefined : _e.getBoundingClientRect();
+        if (bb2) {
+          return {
+            indent,
+            top: bb2.bottom - treeBb.top,
+            left: bb2.left + leftOffset - treeBb.left,
+            width: bb2.width - leftOffset
+          };
+        }
+      }
+      const bb = (_f = targetItem == null ? undefined : targetItem.getElement()) == null ? undefined : _f.getBoundingClientRect();
+      if (bb) {
+        return {
+          indent,
+          top: bb.top - treeBb.top,
+          left: bb.left + leftOffset - treeBb.left,
+          width: bb.width - leftOffset
+        };
+      }
+      return null;
+    },
+    getDragLineStyle: ({ tree }, topOffset = -1, leftOffset = -8) => {
+      const dragLine = tree.getDragLineData();
+      return dragLine ? {
+        position: "absolute",
+        top: `${dragLine.top + topOffset}px`,
+        left: `${dragLine.left + leftOffset}px`,
+        width: `${dragLine.width - leftOffset}px`,
+        pointerEvents: "none"
+      } : { display: "none" };
+    },
+    getContainerProps: ({ prev, tree }, treeLabel) => {
+      const prevProps = prev == null ? undefined : prev(treeLabel);
+      return __spreadProps2(__spreadValues2({}, prevProps), {
+        onDragOver: (e) => {
+          e.preventDefault();
+        },
+        onDrop: (e) => __async(null, null, function* () {
+          var _a, _b, _c;
+          const dataRef = tree.getDataRef();
+          const target = { item: tree.getRootItem() };
+          if (!canDrop(e.dataTransfer, target, tree)) {
+            return;
+          }
+          e.preventDefault();
+          const config = tree.getConfig();
+          const draggedItems = (_a = tree.getState().dnd) == null ? undefined : _a.draggedItems;
+          dataRef.current.lastDragCode = undefined;
+          if (draggedItems) {
+            yield (_b = config.onDrop) == null ? undefined : _b.call(config, draggedItems, target);
+          } else if (e.dataTransfer) {
+            yield (_c = config.onDropForeignDragObject) == null ? undefined : _c.call(config, e.dataTransfer, target);
+          }
+        }),
+        style: __spreadProps2(__spreadValues2({}, prevProps == null ? undefined : prevProps.style), {
+          position: "relative"
+        })
+      });
+    }
+  },
+  itemInstance: {
+    getProps: ({ tree, item, prev }) => __spreadProps2(__spreadValues2(__spreadValues2({}, prev == null ? undefined : prev()), tree.getConfig().seperateDragHandle ? {} : item.getDragHandleProps()), {
+      onDragEnter: (e) => e.preventDefault(),
+      onDragOver: (e) => {
+        var _a, _b, _c;
+        e.stopPropagation();
+        const dataRef = tree.getDataRef();
+        const placement = getTargetPlacement(e, item, tree, true);
+        const nextDragCode = getDragCode(item, placement);
+        if (nextDragCode === dataRef.current.lastDragCode) {
+          if (dataRef.current.lastAllowDrop) {
+            e.preventDefault();
+          }
+          return;
+        }
+        dataRef.current.lastDragCode = nextDragCode;
+        dataRef.current.lastDragEnter = Date.now();
+        handleAutoOpenFolder(dataRef, tree, item, placement);
+        const target = getDragTarget(e, item, tree, false);
+        if (!((_a = tree.getState().dnd) == null ? undefined : _a.draggedItems) && (!e.dataTransfer || !((_c = (_b = tree.getConfig()).canDragForeignDragObjectOver) == null ? undefined : _c.call(_b, e.dataTransfer, target)))) {
+          dataRef.current.lastAllowDrop = false;
+          return;
+        }
+        if (!canDrop(null, target, tree)) {
+          dataRef.current.lastAllowDrop = false;
+          return;
+        }
+        tree.applySubStateUpdate("dnd", (state) => __spreadProps2(__spreadValues2({}, state), {
+          dragTarget: target,
+          draggingOverItem: item
+        }));
+        dataRef.current.lastAllowDrop = true;
+        e.preventDefault();
+      },
+      onDragLeave: () => {
+        setTimeout(() => {
+          var _a;
+          const dataRef = tree.getDataRef();
+          if (((_a = dataRef.current.lastDragEnter) != null ? _a : 0) + 100 >= Date.now())
+            return;
+          dataRef.current.lastDragCode = "no-drag";
+          tree.applySubStateUpdate("dnd", (state) => __spreadProps2(__spreadValues2({}, state), {
+            draggingOverItem: undefined,
+            dragTarget: undefined
+          }));
+        }, 100);
+      },
+      onDrop: (e) => __async(null, null, function* () {
+        var _a, _b, _c;
+        e.stopPropagation();
+        const dataRef = tree.getDataRef();
+        const target = getDragTarget(e, item, tree, true);
+        const draggedItems = (_a = tree.getState().dnd) == null ? undefined : _a.draggedItems;
+        const isValidDrop = canDrop(e.dataTransfer, target, tree);
+        tree.applySubStateUpdate("dnd", {
+          draggedItems: undefined,
+          draggingOverItem: undefined,
+          dragTarget: undefined
+        });
+        if (!isValidDrop) {
+          return;
+        }
+        e.preventDefault();
+        const config = tree.getConfig();
+        dataRef.current.lastDragCode = undefined;
+        if (draggedItems) {
+          yield (_b = config.onDrop) == null ? undefined : _b.call(config, draggedItems, target);
+          draggedItems[0].setFocused();
+        } else if (e.dataTransfer) {
+          yield (_c = config.onDropForeignDragObject) == null ? undefined : _c.call(config, e.dataTransfer, target);
+        }
+        tree.applySubStateUpdate("dnd", null);
+        tree.updateDomFocus();
+      })
+    }),
+    getDragHandleProps: ({ tree, item, prev }) => __spreadProps2(__spreadValues2({}, prev == null ? undefined : prev()), {
+      draggable: true,
+      onDragStart: (e) => {
+        var _a, _b, _c, _d;
+        const { draggedItemOverwritesSelection } = tree.getConfig();
+        const selectedItems = tree.getSelectedItems ? tree.getSelectedItems() : [tree.getFocusedItem()];
+        const overwriteSelection = !selectedItems.includes(item) && draggedItemOverwritesSelection;
+        const items = overwriteSelection ? [item] : selectedItems;
+        const config = tree.getConfig();
+        if (overwriteSelection) {
+          (_a = tree.setSelectedItems) == null || _a.call(tree, [item.getItemMeta().itemId]);
+        }
+        if (!((_c = (_b = config.canDrag) == null ? undefined : _b.call(config, items)) != null ? _c : true)) {
+          e.preventDefault();
+          return;
+        }
+        if (config.setDragImage) {
+          const { imgElement, xOffset, yOffset } = config.setDragImage(items);
+          (_d = e.dataTransfer) == null || _d.setDragImage(imgElement, xOffset != null ? xOffset : 0, yOffset != null ? yOffset : 0);
+        }
+        if (config.createForeignDragObject && e.dataTransfer) {
+          const { format, data, dropEffect, effectAllowed } = config.createForeignDragObject(items);
+          e.dataTransfer.setData(format, data);
+          if (dropEffect)
+            e.dataTransfer.dropEffect = dropEffect;
+          if (effectAllowed)
+            e.dataTransfer.effectAllowed = effectAllowed;
+        }
+        tree.applySubStateUpdate("dnd", {
+          draggedItems: items,
+          draggingOverItem: tree.getFocusedItem()
+        });
+      },
+      onDragEnd: (e) => {
+        var _a, _b;
+        const { onCompleteForeignDrop, canDragForeignDragObjectOver } = tree.getConfig();
+        const draggedItems = (_a = tree.getState().dnd) == null ? undefined : _a.draggedItems;
+        if (((_b = e.dataTransfer) == null ? undefined : _b.dropEffect) === "none" || !draggedItems) {
+          return;
+        }
+        const target = getDragTarget(e, item, tree, false);
+        if (canDragForeignDragObjectOver && e.dataTransfer && !canDragForeignDragObjectOver(e.dataTransfer, target)) {
+          return;
+        }
+        onCompleteForeignDrop == null || onCompleteForeignDrop(draggedItems);
+      }
+    }),
+    isDragTarget: ({ tree, item }) => {
+      const target = tree.getDragTarget();
+      return target ? target.item.getId() === item.getId() : false;
+    },
+    isUnorderedDragTarget: ({ tree, item }) => {
+      const target = tree.getDragTarget();
+      return target ? !isOrderedDragTarget(target) && target.item.getId() === item.getId() : false;
+    },
+    isDragTargetAbove: ({ tree, item }) => {
+      const target = tree.getDragTarget();
+      if (!target || !isOrderedDragTarget(target) || target.item !== item.getParent())
+        return false;
+      return target.childIndex === item.getItemMeta().posInSet;
+    },
+    isDragTargetBelow: ({ tree, item }) => {
+      const target = tree.getDragTarget();
+      if (!target || !isOrderedDragTarget(target) || target.item !== item.getParent())
+        return false;
+      return target.childIndex - 1 === item.getItemMeta().posInSet;
+    },
+    isDraggingOver: ({ tree, item }) => {
+      var _a, _b;
+      return ((_b = (_a = tree.getState().dnd) == null ? undefined : _a.draggingOverItem) == null ? undefined : _b.getId()) === item.getId();
+    }
+  }
+};
+var getNextDragTarget = (tree, isUp, dragTarget) => {
+  var _a, _b, _c, _d;
+  const direction = isUp ? 0 : 1;
+  const draggedItems = (_a = tree.getState().dnd) == null ? undefined : _a.draggedItems;
+  if (isOrderedDragTarget(dragTarget)) {
+    const parent = dragTarget.item.getParent();
+    const targetedItem = tree.getItems()[dragTarget.dragLineIndex - 1];
+    const targetCategory = targetedItem ? getItemDropCategory(targetedItem) : 0;
+    const maxLevel = (_b = targetedItem == null ? undefined : targetedItem.getItemMeta().level) != null ? _b : 0;
+    const minLevel = (_d = (_c = targetedItem == null ? undefined : targetedItem.getItemBelow()) == null ? undefined : _c.getItemMeta().level) != null ? _d : 0;
+    if (targetCategory === 2) {
+      if (isUp && dragTarget.dragLineLevel < maxLevel) {
+        return getReparentTarget(targetedItem, dragTarget.dragLineLevel + 1, draggedItems);
+      }
+      if (!isUp && dragTarget.dragLineLevel > minLevel && parent) {
+        return getReparentTarget(targetedItem, dragTarget.dragLineLevel - 1, draggedItems);
+      }
+    }
+    const newIndex = dragTarget.dragLineIndex - 1 + direction;
+    const item = tree.getItems()[newIndex];
+    return item ? { item } : undefined;
+  }
+  const targetingExpandedFolder = getItemDropCategory(dragTarget.item) === 1;
+  if (targetingExpandedFolder && !isUp) {
+    return {
+      item: dragTarget.item,
+      childIndex: 0,
+      insertionIndex: getInsertionIndex(dragTarget.item.getChildren(), 0, draggedItems),
+      dragLineIndex: dragTarget.item.getItemMeta().index + direction,
+      dragLineLevel: dragTarget.item.getItemMeta().level + 1
+    };
+  }
+  const childIndex = dragTarget.item.getIndexInParent() + direction;
+  return {
+    item: dragTarget.item.getParent(),
+    childIndex,
+    insertionIndex: getInsertionIndex(dragTarget.item.getParent().getChildren(), childIndex, draggedItems),
+    dragLineIndex: dragTarget.item.getItemMeta().index + direction,
+    dragLineLevel: dragTarget.item.getItemMeta().level
+  };
+};
+var getNextValidDragTarget = (tree, isUp, previousTarget = ((_a) => (_a = tree.getState().dnd) == null ? undefined : _a.dragTarget)()) => {
+  var _a2;
+  if (!previousTarget)
+    return;
+  const nextTarget = getNextDragTarget(tree, isUp, previousTarget);
+  const dataTransfer = (_a2 = tree.getDataRef().current.kDndDataTransfer) != null ? _a2 : null;
+  if (!nextTarget)
+    return;
+  if (!tree.getConfig().canReorder && isOrderedDragTarget(nextTarget)) {
+    return getNextValidDragTarget(tree, isUp, nextTarget);
+  }
+  if (canDrop(dataTransfer, nextTarget, tree)) {
+    return nextTarget;
+  }
+  return getNextValidDragTarget(tree, isUp, nextTarget);
+};
+var updateScroll = (tree) => {
+  const state = tree.getState().dnd;
+  if (!(state == null ? undefined : state.dragTarget) || isOrderedDragTarget(state.dragTarget))
+    return;
+  state.dragTarget.item.scrollTo({ block: "nearest", inline: "nearest" });
+};
+var initiateDrag = (tree, draggedItems, dataTransfer) => {
+  var _a, _b;
+  const focusedItem = tree.getFocusedItem();
+  const { canDrag } = tree.getConfig();
+  if (draggedItems && canDrag && !canDrag(draggedItems)) {
+    return;
+  }
+  if (draggedItems) {
+    tree.applySubStateUpdate("dnd", { draggedItems });
+    (_b = (_a = tree.getConfig()).onStartKeyboardDrag) == null || _b.call(_a, draggedItems);
+  } else if (dataTransfer) {
+    tree.getDataRef().current.kDndDataTransfer = dataTransfer;
+  }
+  const dragTarget = getNextValidDragTarget(tree, false, {
+    item: focusedItem
+  });
+  if (!dragTarget)
+    return;
+  tree.applySubStateUpdate("dnd", {
+    draggedItems,
+    dragTarget
+  });
+  tree.applySubStateUpdate("assistiveDndState", 1);
+  updateScroll(tree);
+};
+var moveDragPosition = (tree, isUp) => {
+  var _a;
+  const dragTarget = getNextValidDragTarget(tree, isUp);
+  if (!dragTarget)
+    return;
+  tree.applySubStateUpdate("dnd", {
+    draggedItems: (_a = tree.getState().dnd) == null ? undefined : _a.draggedItems,
+    dragTarget
+  });
+  tree.applySubStateUpdate("assistiveDndState", 2);
+  if (!isOrderedDragTarget(dragTarget)) {
+    dragTarget.item.setFocused();
+  }
+  updateScroll(tree);
+};
+var keyboardDragAndDropFeature = {
+  key: "keyboard-drag-and-drop",
+  deps: ["drag-and-drop"],
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    setAssistiveDndState: makeStateUpdater("assistiveDndState", tree)
+  }, defaultConfig),
+  stateHandlerNames: {
+    assistiveDndState: "setAssistiveDndState"
+  },
+  treeInstance: {
+    startKeyboardDrag: ({ tree }, draggedItems) => {
+      initiateDrag(tree, draggedItems, undefined);
+    },
+    startKeyboardDragOnForeignObject: ({ tree }, dataTransfer) => {
+      initiateDrag(tree, undefined, dataTransfer);
+    },
+    stopKeyboardDrag: ({ tree }) => {
+      tree.getDataRef().current.kDndDataTransfer = undefined;
+      tree.applySubStateUpdate("dnd", null);
+      tree.applySubStateUpdate("assistiveDndState", 0);
+    }
+  },
+  hotkeys: {
+    startDrag: {
+      hotkey: "Control+Shift+KeyD",
+      preventDefault: true,
+      isEnabled: (tree) => !tree.getState().dnd,
+      handler: (_, tree) => {
+        var _a, _b;
+        const selectedItems = (_b = (_a = tree.getSelectedItems) == null ? undefined : _a.call(tree)) != null ? _b : [
+          tree.getFocusedItem()
+        ];
+        const focusedItem = tree.getFocusedItem();
+        tree.startKeyboardDrag(selectedItems.includes(focusedItem) ? selectedItems : selectedItems.concat(focusedItem));
+      }
+    },
+    dragUp: {
+      hotkey: "ArrowUp",
+      preventDefault: true,
+      isEnabled: (tree) => !!tree.getState().dnd,
+      handler: (_, tree) => {
+        moveDragPosition(tree, true);
+      }
+    },
+    dragDown: {
+      hotkey: "ArrowDown",
+      preventDefault: true,
+      isEnabled: (tree) => !!tree.getState().dnd,
+      handler: (_, tree) => {
+        moveDragPosition(tree, false);
+      }
+    },
+    cancelDrag: {
+      hotkey: "Escape",
+      isEnabled: (tree) => !!tree.getState().dnd,
+      handler: (_, tree) => {
+        tree.stopKeyboardDrag();
+      }
+    },
+    completeDrag: {
+      hotkey: "Enter",
+      preventDefault: true,
+      isEnabled: (tree) => !!tree.getState().dnd,
+      handler: (e, tree) => __async(null, null, function* () {
+        var _a, _b, _c, _d;
+        e.stopPropagation();
+        const dataRef = tree.getDataRef();
+        const target = tree.getDragTarget();
+        const dataTransfer = (_a = dataRef.current.kDndDataTransfer) != null ? _a : null;
+        if (!target || !canDrop(dataTransfer, target, tree)) {
+          return;
+        }
+        const config = tree.getConfig();
+        const draggedItems = (_b = tree.getState().dnd) == null ? undefined : _b.draggedItems;
+        dataRef.current.lastDragCode = undefined;
+        tree.applySubStateUpdate("dnd", null);
+        if (draggedItems) {
+          yield (_c = config.onDrop) == null ? undefined : _c.call(config, draggedItems, target);
+          tree.getItemInstance(draggedItems[0].getId()).setFocused();
+        } else if (dataTransfer) {
+          yield (_d = config.onDropForeignDragObject) == null ? undefined : _d.call(config, dataTransfer, target);
+        }
+        tree.updateDomFocus();
+        tree.applySubStateUpdate("assistiveDndState", 3);
+      })
+    }
+  }
+};
+var searchFeature = {
+  key: "search",
+  getInitialState: (initialState) => __spreadValues2({
+    search: null
+  }, initialState),
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    setSearch: makeStateUpdater("search", tree),
+    isSearchMatchingItem: (search, item) => search.length > 0 && item.getItemName().toLowerCase().includes(search.toLowerCase())
+  }, defaultConfig),
+  stateHandlerNames: {
+    search: "setSearch"
+  },
+  treeInstance: {
+    setSearch: ({ tree }, search) => {
+      var _a;
+      tree.applySubStateUpdate("search", search);
+      (_a = tree.getItems().find((item) => {
+        var _a2, _b;
+        return (_b = (_a2 = tree.getConfig()).isSearchMatchingItem) == null ? undefined : _b.call(_a2, tree.getSearchValue(), item);
+      })) == null || _a.setFocused();
+    },
+    openSearch: ({ tree }, initialValue = "") => {
+      var _a, _b;
+      tree.setSearch(initialValue);
+      (_b = (_a = tree.getConfig()).onOpenSearch) == null || _b.call(_a);
+      setTimeout(() => {
+        var _a2;
+        (_a2 = tree.getDataRef().current.searchInput) == null || _a2.focus();
+      });
+    },
+    closeSearch: ({ tree }) => {
+      var _a, _b;
+      tree.setSearch(null);
+      (_b = (_a = tree.getConfig()).onCloseSearch) == null || _b.call(_a);
+      tree.updateDomFocus();
+    },
+    isSearchOpen: ({ tree }) => tree.getState().search !== null,
+    getSearchValue: ({ tree }) => tree.getState().search || "",
+    registerSearchInputElement: ({ tree }, element) => {
+      const dataRef = tree.getDataRef();
+      dataRef.current.searchInput = element;
+      if (element && dataRef.current.keydownHandler) {
+        element.addEventListener("keydown", dataRef.current.keydownHandler);
+      }
+    },
+    getSearchInputElement: ({ tree }) => {
+      var _a;
+      return (_a = tree.getDataRef().current.searchInput) != null ? _a : null;
+    },
+    getSearchInputElementProps: ({ tree }) => ({
+      value: tree.getSearchValue(),
+      onChange: (e) => tree.setSearch(e.target.value),
+      onBlur: () => tree.closeSearch(),
+      ref: tree.registerSearchInputElement
+    }),
+    getSearchMatchingItems: memo(({ tree }) => [
+      tree.getSearchValue(),
+      tree.getItems(),
+      tree.getConfig().isSearchMatchingItem
+    ], (search, items, isSearchMatchingItem) => items.filter((item) => search && (isSearchMatchingItem == null ? undefined : isSearchMatchingItem(search, item))))
+  },
+  itemInstance: {
+    isMatchingSearch: ({ tree, item }) => tree.getSearchMatchingItems().some((i) => i.getId() === item.getId())
+  },
+  hotkeys: {
+    openSearch: {
+      hotkey: "LetterOrNumber",
+      preventDefault: true,
+      isEnabled: (tree) => !tree.isSearchOpen(),
+      handler: (e, tree) => {
+        e.stopPropagation();
+        tree.openSearch(e.key);
+      }
+    },
+    closeSearch: {
+      hotkey: "Escape",
+      allowWhenInputFocused: true,
+      isEnabled: (tree) => tree.isSearchOpen(),
+      handler: (e, tree) => {
+        tree.closeSearch();
+      }
+    },
+    submitSearch: {
+      hotkey: "Enter",
+      allowWhenInputFocused: true,
+      isEnabled: (tree) => tree.isSearchOpen(),
+      handler: (e, tree) => {
+        tree.closeSearch();
+        tree.setSelectedItems([tree.getFocusedItem().getId()]);
+      }
+    },
+    nextSearchItem: {
+      hotkey: "ArrowDown",
+      allowWhenInputFocused: true,
+      canRepeat: true,
+      isEnabled: (tree) => tree.isSearchOpen(),
+      handler: (e, tree) => {
+        const focusItem = tree.getSearchMatchingItems().find((item) => item.getItemMeta().index > tree.getFocusedItem().getItemMeta().index);
+        focusItem == null || focusItem.setFocused();
+        focusItem == null || focusItem.scrollTo({ block: "nearest", inline: "nearest" });
+      }
+    },
+    previousSearchItem: {
+      hotkey: "ArrowUp",
+      allowWhenInputFocused: true,
+      canRepeat: true,
+      isEnabled: (tree) => tree.isSearchOpen(),
+      handler: (e, tree) => {
+        const focusItem = [...tree.getSearchMatchingItems()].reverse().find((item) => item.getItemMeta().index < tree.getFocusedItem().getItemMeta().index);
+        focusItem == null || focusItem.setFocused();
+        focusItem == null || focusItem.scrollTo({ block: "nearest", inline: "nearest" });
+      }
+    }
+  }
+};
+var renamingFeature = {
+  key: "renaming",
+  overwrites: ["drag-and-drop"],
+  getDefaultConfig: (defaultConfig, tree) => __spreadValues2({
+    setRenamingItem: makeStateUpdater("renamingItem", tree),
+    setRenamingValue: makeStateUpdater("renamingValue", tree),
+    canRename: () => true
+  }, defaultConfig),
+  stateHandlerNames: {
+    renamingItem: "setRenamingItem",
+    renamingValue: "setRenamingValue"
+  },
+  treeInstance: {
+    getRenamingItem: ({ tree }) => {
+      const itemId = tree.getState().renamingItem;
+      return itemId ? tree.getItemInstance(itemId) : null;
+    },
+    getRenamingValue: ({ tree }) => tree.getState().renamingValue || "",
+    abortRenaming: ({ tree }) => {
+      tree.applySubStateUpdate("renamingItem", null);
+      tree.updateDomFocus();
+    },
+    completeRenaming: ({ tree }) => {
+      var _a;
+      const config = tree.getConfig();
+      const item = tree.getRenamingItem();
+      if (item) {
+        (_a = config.onRename) == null || _a.call(config, item, tree.getState().renamingValue || "");
+      }
+      tree.applySubStateUpdate("renamingItem", null);
+      tree.updateDomFocus();
+    },
+    isRenamingItem: ({ tree }) => !!tree.getState().renamingItem
+  },
+  itemInstance: {
+    startRenaming: ({ tree, item, itemId }) => {
+      if (!item.canRename()) {
+        return;
+      }
+      tree.applySubStateUpdate("renamingItem", itemId);
+      tree.applySubStateUpdate("renamingValue", item.getItemName());
+    },
+    getRenameInputProps: ({ tree }) => ({
+      ref: (r) => r == null ? undefined : r.focus(),
+      onBlur: () => tree.abortRenaming(),
+      value: tree.getRenamingValue(),
+      onChange: (e) => {
+        var _a;
+        tree.applySubStateUpdate("renamingValue", (_a = e.target) == null ? undefined : _a.value);
+      }
+    }),
+    canRename: ({ tree, item }) => {
+      var _a, _b, _c;
+      return (_c = (_b = (_a = tree.getConfig()).canRename) == null ? undefined : _b.call(_a, item)) != null ? _c : true;
+    },
+    isRenaming: ({ tree, item }) => item.getId() === tree.getState().renamingItem,
+    getProps: ({ prev, item }) => {
+      var _a;
+      const isRenaming = item.isRenaming();
+      const prevProps = (_a = prev == null ? undefined : prev()) != null ? _a : {};
+      return isRenaming ? __spreadProps2(__spreadValues2({}, prevProps), {
+        draggable: false,
+        onDragStart: () => {}
+      }) : prevProps;
+    }
+  },
+  hotkeys: {
+    renameItem: {
+      hotkey: "F2",
+      handler: (e, tree) => {
+        tree.getFocusedItem().startRenaming();
+      }
+    },
+    abortRenaming: {
+      hotkey: "Escape",
+      allowWhenInputFocused: true,
+      isEnabled: (tree) => tree.isRenamingItem(),
+      handler: (e, tree) => {
+        tree.abortRenaming();
+      }
+    },
+    completeRenaming: {
+      hotkey: "Enter",
+      allowWhenInputFocused: true,
+      isEnabled: (tree) => tree.isRenamingItem(),
+      handler: (e, tree) => {
+        tree.completeRenaming();
+      }
+    }
+  }
+};
+var expandAllFeature = {
+  key: "expand-all",
+  treeInstance: {
+    expandAll: (_0, _1) => __async(null, [_0, _1], function* ({ tree }, cancelToken) {
+      yield Promise.all(tree.getItems().map((item) => item.expandAll(cancelToken)));
+    }),
+    collapseAll: ({ tree }) => {
+      tree.applySubStateUpdate("expandedItems", []);
+      tree.rebuildTree();
+    }
+  },
+  itemInstance: {
+    expandAll: (_0, _1) => __async(null, [_0, _1], function* ({ tree, item }, cancelToken) {
+      if (cancelToken == null ? undefined : cancelToken.current) {
+        return;
+      }
+      if (!item.isFolder()) {
+        return;
+      }
+      item.expand();
+      yield tree.waitForItemChildrenLoaded(item.getId());
+      yield Promise.all(item.getChildren().map((child) => __async(null, null, function* () {
+        yield tree.waitForItemChildrenLoaded(item.getId());
+        yield child == null ? undefined : child.expandAll(cancelToken);
+      })));
+    }),
+    collapseAll: ({ item }) => {
+      if (!item.isExpanded())
+        return;
+      for (const child of item.getChildren()) {
+        child == null || child.collapseAll();
+      }
+      item.collapse();
+    }
+  },
+  hotkeys: {
+    expandSelected: {
+      hotkey: "Control+Shift+Plus",
+      handler: (_, tree) => __async(null, null, function* () {
+        const cancelToken = { current: false };
+        const cancelHandler = (e) => {
+          if (e.code === "Escape") {
+            cancelToken.current = true;
+          }
+        };
+        document.addEventListener("keydown", cancelHandler);
+        yield Promise.all(tree.getSelectedItems().map((item) => item.expandAll(cancelToken)));
+        document.removeEventListener("keydown", cancelHandler);
+      })
+    },
+    collapseSelected: {
+      hotkey: "Control+Shift+Minus",
+      handler: (_, tree) => {
+        tree.getSelectedItems().forEach((item) => item.collapseAll());
+      }
+    }
+  }
+};
+
+// node_modules/@headless-tree/react/dist/index.mjs
+import { useEffect, useState } from "react";
+var styles = {
+  position: "absolute",
+  margin: "-1px",
+  width: "1px",
+  height: "1px",
+  overflow: "hidden",
+  clip: "rect(0 0 0 0)"
+};
+var getDefaultLabel = (dnd, assistiveState, hotkeys) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (!hotkeys.startDrag)
+    return "";
+  const itemNames = (_b = (_a = dnd == null ? undefined : dnd.draggedItems) == null ? undefined : _a.map((item) => item.getItemName()).join(", ")) != null ? _b : "";
+  const position = !(dnd == null ? undefined : dnd.dragTarget) ? "None" : ("childIndex" in dnd.dragTarget) ? `${dnd.dragTarget.childIndex} of ${dnd.dragTarget.item.getChildren().length} in ${dnd.dragTarget.item.getItemName()}` : `in ${dnd.dragTarget.item.getItemName()}`;
+  const navGuide = `Press ${(_c = hotkeys.dragUp) == null ? undefined : _c.hotkey} and ${(_d = hotkeys.dragDown) == null ? undefined : _d.hotkey} to move up or down, ${(_e = hotkeys.completeDrag) == null ? undefined : _e.hotkey} to drop, ${(_f = hotkeys.cancelDrag) == null ? undefined : _f.hotkey} to abort.`;
+  switch (assistiveState) {
+    case AssistiveDndState.Started:
+      return itemNames ? `Dragging ${itemNames}. Current position: ${position}. ${navGuide}` : `Current position: ${position}. ${navGuide}`;
+    case AssistiveDndState.Dragging:
+      return itemNames ? `${itemNames}, ${position}` : position;
+    case AssistiveDndState.Completed:
+      return `Drag completed. Press ${(_g = hotkeys.startDrag) == null ? undefined : _g.hotkey} to move selected items`;
+    case AssistiveDndState.Aborted:
+      return `Drag cancelled. Press ${(_h = hotkeys.startDrag) == null ? undefined : _h.hotkey} to move selected items`;
+    case AssistiveDndState.None:
+    default:
+      return `Press ${(_i = hotkeys.startDrag) == null ? undefined : _i.hotkey} to move selected items`;
+  }
+};
+var AssistiveTreeDescription = (_a) => {
+  var _b = _a, {
+    tree,
+    getLabel = getDefaultLabel
+  } = _b, props = __objRest(_b, [
+    "tree",
+    "getLabel"
+  ]);
+  var _a2;
+  const state = tree.getState();
+  return /* @__PURE__ */ React.createElement("span", __spreadProps(__spreadValues({
+    "aria-live": "assertive"
+  }, props), {
+    style: __spreadValues(__spreadValues({}, styles), props.style)
+  }), getLabel(state.dnd, (_a2 = state.assistiveDndState) != null ? _a2 : AssistiveDndState.None, tree.getHotkeyPresets()));
+};
+var useTree = (config) => {
+  const [tree] = useState(() => ({ current: createTree(config) }));
+  const [state, setState] = useState(() => tree.current.getState());
+  useEffect(() => {
+    tree.current.setMounted(true);
+    tree.current.rebuildTree();
+    return () => {
+      tree.current.setMounted(false);
+    };
+  }, [tree]);
+  tree.current.setConfig((prev) => __spreadProps(__spreadValues(__spreadValues({}, prev), config), {
+    state: __spreadValues(__spreadValues({}, state), config.state),
+    setState: (state2) => {
+      var _a;
+      setState(state2);
+      (_a = config.setState) == null || _a.call(config, state2);
+    }
+  }));
+  return tree.current;
+};
 export {
   AssistiveTreeDescription,
   Tree,