@lostgradient/cinder 0.4.0 → 0.4.1

package/dist/server/index.server-kq859dmc.js

@@ -0,0 +1,1543 @@
+import {
+  Tree_item,
+  getTreeContext,
+  setTreeContextRaw,
+  setTreeItemParentContextRaw
+} from "./index.server-wj91h1wk.js";
+import {
+  Virtualizer
+} from "./index.server-ny1hfypg.js";
+import {
+  inDocumentOrder
+} from "./index.server-h54v6c32.js";
+import {
+  TypeaheadBuffer,
+  findTypeaheadMatch,
+  isTypeaheadKey
+} from "./index.server-bgcpy5vk.js";
+import {
+  _visually_hidden_live_region
+} from "./index.server-hmw4afhn.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/_tree-expand-all/tree-expand-all.svelte
+import * as $ from "svelte/internal/server";
+function Tree_expand_all($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      label = "Tree expansion",
+      expandAllLabel = "Expand all",
+      expandOneLevelLabel = "Expand one level",
+      collapseAllLabel = "Collapse all",
+      safetyThreshold = 500,
+      class: className
+    } = $$props;
+    const context = getTreeContext();
+    const expandDisabled = $.derived(() => context.expandableBranchCount === 0);
+    const collapseDisabled = $.derived(() => !context.hasExpandedItems);
+    const showSafetyValve = $.derived(() => context.expandableBranchCount > safetyThreshold);
+    function expandAll() {
+      if (!expandDisabled())
+        context.expandAll();
+    }
+    function expandOneLevel() {
+      if (!expandDisabled())
+        context.expandOneLevel();
+    }
+    function collapseAll() {
+      if (!collapseDisabled())
+        context.collapseAll();
+    }
+    $$renderer2.push(`<div${$.attr_class($.clsx(classNames("cinder-tree-expand-all", className)))}><span class="cinder-tree-expand-all__label">${$.escape(label)}</span> `);
+    if (showSafetyValve()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<button type="button" class="cinder-tree-expand-all__button"${$.attr("aria-label", `${expandOneLevelLabel}: ${label}`)}${$.attr("disabled", expandDisabled(), true)}>${$.escape(expandOneLevelLabel)}</button>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <button type="button" class="cinder-tree-expand-all__button"${$.attr("aria-label", `${expandAllLabel}: ${label}`)}${$.attr("disabled", expandDisabled(), true)}>${$.escape(expandAllLabel)}</button> <button type="button" class="cinder-tree-expand-all__button"${$.attr("aria-label", `${collapseAllLabel}: ${label}`)}${$.attr("disabled", collapseDisabled(), true)}>${$.escape(collapseAllLabel)}</button></div>`);
+  });
+}
+
+// src/components/_tree-select-all/tree-select-all.svelte
+import * as $2 from "svelte/internal/server";
+function Tree_select_all($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      parentId = null,
+      includeDescendants = false,
+      label = "Tree selection",
+      selectAllLabel = "Select all",
+      selectNoneLabel = "Select none",
+      class: className
+    } = $$props;
+    const context = getTreeContext();
+    const disabled = $2.derived(() => !context.multiselectable || !context.hasSelectableSelectionScope(parentId, includeDescendants));
+    function selectAll() {
+      if (!disabled())
+        context.selectSelectionScope(parentId, true, includeDescendants);
+    }
+    function selectNone() {
+      if (!disabled())
+        context.selectSelectionScope(parentId, false, includeDescendants);
+    }
+    $$renderer2.push(`<div${$2.attr_class($2.clsx(classNames("cinder-tree-select-all", className)))}><span class="cinder-tree-select-all__label">${$2.escape(label)}</span> <button type="button" class="cinder-tree-select-all__button"${$2.attr("aria-label", `${selectAllLabel}: ${label}`)}${$2.attr("disabled", disabled(), true)}>${$2.escape(selectAllLabel)}</button> <button type="button" class="cinder-tree-select-all__button"${$2.attr("aria-label", `${selectNoneLabel}: ${label}`)}${$2.attr("disabled", disabled(), true)}>${$2.escape(selectNoneLabel)}</button></div>`);
+  });
+}
+
+// src/components/tree/tree.svelte
+import * as $5 from "svelte/internal/server";
+import { tick, untrack } from "svelte";
+import { SvelteSet } from "svelte/reactivity";
+
+// src/_internal/tree-data.ts
+function flattenTreeDataItems(items) {
+  const flattenedItems = [];
+  const visit = (children, parentId, level, ancestorIds) => {
+    const setSize = children.length;
+    children.forEach((item, siblingIndex) => {
+      const branch = (item.children?.length ?? 0) > 0;
+      const flattenedItem = {
+        id: item.id,
+        label: item.label,
+        disabled: item.disabled ?? false,
+        parentId,
+        level,
+        branch,
+        index: flattenedItems.length,
+        posInSet: siblingIndex + 1,
+        setSize,
+        ancestorIds
+      };
+      flattenedItems.push(flattenedItem);
+      if (branch) {
+        visit(item.children ?? [], item.id, level + 1, [...ancestorIds, item.id]);
+      }
+    });
+  };
+  visit(items, null, 1, []);
+  return flattenedItems;
+}
+function visibleTreeDataItems(flattenedItems, expandedIds, filterPredicate) {
+  if (filterPredicate) {
+    const byId = new Map(flattenedItems.map((item) => [item.id, item]));
+    const retainedIds = new Set;
+    for (const item of flattenedItems) {
+      if (!filterPredicate(item))
+        continue;
+      retainedIds.add(item.id);
+      for (const ancestorId of item.ancestorIds) {
+        if (byId.has(ancestorId))
+          retainedIds.add(ancestorId);
+      }
+    }
+    return flattenedItems.filter((item) => retainedIds.has(item.id));
+  }
+  const expandedIdSet = new Set(expandedIds);
+  return flattenedItems.filter((item) => item.ancestorIds.every((ancestorId) => expandedIdSet.has(ancestorId)));
+}
+function descendantTreeDataIds(flattenedItems, parentId) {
+  const parent = flattenedItems.find((item) => item.id === parentId);
+  if (!parent)
+    return [];
+  return flattenedItems.filter((item) => item.ancestorIds.includes(parentId) && item.level > parent.level).map((item) => item.id);
+}
+
+// src/_internal/tree-registry.svelte.ts
+import * as $3 from "svelte/internal/server";
+import { SvelteMap } from "svelte/reactivity";
+class TreeRegistry {
+  #nodes = new SvelteMap;
+  #children = new SvelteMap;
+  get size() {
+    return this.#nodes.size;
+  }
+  register(node) {
+    if (this.#nodes.has(node.id)) {
+      throw new Error(`[cinder-tree] Duplicate TreeItem id: "${node.id}". All node ids must be unique within the tree.`);
+    }
+    this.#nodes.set(node.id, node);
+    const siblings = this.#children.get(node.parentId) ?? [];
+    this.#children.set(node.parentId, [...siblings, node.id]);
+    return () => {
+      this.#nodes.delete(node.id);
+      const remaining = (this.#children.get(node.parentId) ?? []).filter((id) => id !== node.id);
+      if (remaining.length === 0) {
+        this.#children.delete(node.parentId);
+      } else {
+        this.#children.set(node.parentId, remaining);
+      }
+    };
+  }
+  #orderedChildren(parentId) {
+    const ids = this.#children.get(parentId);
+    if (!ids || ids.length <= 1)
+      return ids ?? [];
+    const withNodes = ids.map((id) => ({ id, node: this.#nodes.get(id)?.node })).filter((entry) => entry.node !== undefined);
+    return inDocumentOrder(withNodes).map((entry) => entry.id);
+  }
+  getVisible(expandedIds, visibilityPredicate) {
+    const result = [];
+    const expandedSet = new Set(expandedIds);
+    const retainedIds = visibilityPredicate ? this.#retainedIdsForPredicate(visibilityPredicate) : undefined;
+    const visit = (parentId) => {
+      const childIds = this.#orderedChildren(parentId);
+      for (const id of childIds) {
+        if (retainedIds && !retainedIds.has(id))
+          continue;
+        result.push(id);
+        const node = this.#nodes.get(id);
+        if (node?.isBranch() && (expandedSet.has(id) || retainedIds?.has(id))) {
+          visit(id);
+        }
+      }
+    };
+    visit(null);
+    return result;
+  }
+  #retainedIdsForPredicate(visibilityPredicate) {
+    const retainedIds = new Set;
+    for (const [id, node] of this.#nodes) {
+      if (!visibilityPredicate({
+        id,
+        label: node.label(),
+        parentId: node.parentId,
+        level: node.level
+      })) {
+        continue;
+      }
+      retainedIds.add(id);
+      let parentId = node.parentId;
+      while (parentId !== null) {
+        retainedIds.add(parentId);
+        parentId = this.parentOf(parentId) ?? null;
+      }
+    }
+    return retainedIds;
+  }
+  getNode(id) {
+    return this.#nodes.get(id);
+  }
+  parentOf(id) {
+    return this.#nodes.get(id)?.parentId;
+  }
+  firstChildOf(id) {
+    return this.#orderedChildren(id)[0];
+  }
+  childrenOf(parentId) {
+    return this.#orderedChildren(parentId);
+  }
+  descendantsOf(parentId) {
+    const result = [];
+    const visit = (id) => {
+      for (const childId of this.#orderedChildren(id)) {
+        result.push(childId);
+        visit(childId);
+      }
+    };
+    visit(parentId);
+    return result;
+  }
+  getAllBranchIds(options = {}) {
+    const result = [];
+    const visit = (parentId) => {
+      for (const id of this.#orderedChildren(parentId)) {
+        const node = this.#nodes.get(id);
+        if (!node?.isBranch())
+          continue;
+        if (!options.bulkOnly || this.isBulkExpandableBranch(id)) {
+          result.push(id);
+        }
+        visit(id);
+      }
+    };
+    visit(null);
+    return result;
+  }
+  isBulkExpandableBranch(id) {
+    const node = this.#nodes.get(id);
+    return Boolean(node?.isBranch() && (node.bulkExpandable?.() ?? true));
+  }
+  ancestorsOf(id) {
+    const result = [];
+    let parentId = this.parentOf(id);
+    while (parentId !== null && parentId !== undefined) {
+      result.push(parentId);
+      parentId = this.parentOf(parentId);
+    }
+    return result;
+  }
+  siblingsOf(id) {
+    const node = this.#nodes.get(id);
+    if (!node)
+      return [];
+    return this.#orderedChildren(node.parentId);
+  }
+  typeaheadMatch(prefix, currentId, expandedIds, visibilityPredicate) {
+    const visible = this.getVisible(expandedIds, visibilityPredicate);
+    return findTypeaheadMatch(visible.map((id) => {
+      const node = this.#nodes.get(id);
+      return {
+        value: id,
+        label: node?.label() ?? "",
+        disabled: node?.disabled
+      };
+    }), prefix, visible.indexOf(currentId));
+  }
+}
+
+// src/_internal/use-virtualizer.svelte.ts
+import * as $4 from "svelte/internal/server";
+import { createSubscriber } from "svelte/reactivity";
+
+class TreeVirtualizer {
+  options;
+  #virtualizer = null;
+  #scrollElement = null;
+  #update = () => {};
+  #subscribe;
+  constructor(options) {
+    this.options = options;
+    this.#subscribe = createSubscriber((update) => {
+      if (typeof window === "undefined")
+        return;
+      this.#update = update;
+      this.#virtualizer = new Virtualizer(this.#buildOptions());
+      const cleanup = this.#virtualizer._didMount();
+      this.#virtualizer._willUpdate();
+      update();
+      return () => {
+        cleanup();
+        this.#virtualizer = null;
+      };
+    });
+  }
+  get virtualItems() {
+    this.#subscribe();
+    this.#syncOptions();
+    const fallbackItems = this.#fallbackVirtualItems();
+    const virtualizerItems = this.#virtualizer?.getVirtualItems();
+    const items = this.#shouldUseFallbackVirtualItems(virtualizerItems, fallbackItems) ? fallbackItems : virtualizerItems ?? fallbackItems;
+    return items.map((item) => ({ ...item }));
+  }
+  get totalSize() {
+    this.#subscribe();
+    this.#syncOptions();
+    return this.#virtualizer?.getTotalSize() ?? this.options.getCount() * this.options.getEstimatedSize();
+  }
+  setScrollElement(element) {
+    if (this.#scrollElement === element)
+      return;
+    this.#scrollElement = element;
+    this.#syncOptions();
+    this.#update();
+  }
+  scrollElement = (node) => {
+    this.setScrollElement(node);
+    return () => {
+      if (this.#scrollElement === node) {
+        this.setScrollElement(null);
+      }
+    };
+  };
+  measureElement = (node) => {
+    this.#syncOptions();
+    this.#virtualizer?.measureElement(node);
+    return () => this.#virtualizer?.measureElement(null);
+  };
+  scrollToIndex(index, options = { align: "auto" }) {
+    this.#subscribe();
+    this.#syncOptions();
+    const element = this.#getScrollElement();
+    const shouldUseFallbackScroll = Boolean(element && (!this.#virtualizer || element.clientHeight === 0));
+    this.#virtualizer?.scrollToIndex(index, options);
+    if (!element || !shouldUseFallbackScroll)
+      return;
+    element.scrollTop = Math.max(0, index * Math.max(1, this.options.getEstimatedSize()));
+    element.dispatchEvent(new Event("scroll"));
+  }
+  #syncOptions() {
+    if (!this.#virtualizer)
+      return;
+    this.#virtualizer.setOptions(this.#buildOptions());
+    this.#virtualizer._willUpdate();
+  }
+  #getScrollElement = () => this.#scrollElement ?? this.options.getScrollElement();
+  #buildOptions() {
+    return {
+      count: this.options.getCount(),
+      getScrollElement: this.#getScrollElement,
+      getItemKey: this.options.getItemKey,
+      estimateSize: () => this.options.getEstimatedSize(),
+      overscan: this.#overscan(),
+      initialRect: { width: 0, height: this.options.getInitialHeight() },
+      observeElementRect: this.#observeElementRect,
+      observeElementOffset: this.#observeElementOffset,
+      scrollToFn: this.#scrollToOffset,
+      measureElement: this.#measureElement,
+      onChange: () => this.#update(),
+      indexAttribute: "data-cinder-virtual-index"
+    };
+  }
+  #scrollToOffset = (offset, { adjustments = 0, behavior }, instance) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return;
+    const top = offset + adjustments;
+    if (typeof element.scrollTo === "function") {
+      element.scrollTo(behavior ? { top, behavior } : { top });
+      return;
+    }
+    element.scrollTop = top;
+  };
+  #observeElementRect = (instance, callback) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return () => {};
+    const notify = () => {
+      const rect = element.getBoundingClientRect();
+      callback({
+        width: rect.width,
+        height: rect.height || element.clientHeight || this.options.getInitialHeight()
+      });
+    };
+    notify();
+    if (typeof ResizeObserver === "undefined")
+      return () => {};
+    const observer = new ResizeObserver(notify);
+    observer.observe(element);
+    return () => observer.disconnect();
+  };
+  #measureElement = (element) => {
+    const rect = element.getBoundingClientRect();
+    return rect.height || this.options.getEstimatedSize();
+  };
+  #fallbackVirtualItems() {
+    const count = this.options.getCount();
+    if (count === 0)
+      return [];
+    const size = Math.max(1, this.options.getEstimatedSize());
+    const overscan = this.#overscan();
+    const scrollTop = this.#getScrollElement()?.scrollTop ?? 0;
+    const visibleCount = Math.ceil(this.options.getInitialHeight() / size);
+    const startIndex = Math.max(0, Math.floor(scrollTop / size) - overscan);
+    const itemCount = Math.min(count - startIndex, visibleCount + overscan * 2);
+    return Array.from({ length: itemCount }, (_, offset) => {
+      const index = startIndex + offset;
+      return {
+        key: this.options.getItemKey(index),
+        index,
+        start: index * size,
+        end: (index + 1) * size,
+        size,
+        lane: 0
+      };
+    });
+  }
+  #shouldUseFallbackVirtualItems(virtualizerItems, fallbackItems) {
+    if (!virtualizerItems || fallbackItems.length === 0) {
+      return false;
+    }
+    if (virtualizerItems.length === 0)
+      return true;
+    const scrollTop = this.#getScrollElement()?.scrollTop ?? 0;
+    if (scrollTop <= 0)
+      return false;
+    const firstVirtualizerIndex = virtualizerItems[0]?.index ?? 0;
+    const firstFallbackIndex = fallbackItems[0]?.index ?? 0;
+    return Math.abs(firstVirtualizerIndex - firstFallbackIndex) > 1;
+  }
+  #overscan() {
+    return Math.max(0, this.options.getOverscan());
+  }
+  #observeElementOffset = (instance, callback) => {
+    const element = instance.scrollElement;
+    if (!element)
+      return () => {};
+    const notify = () => {
+      callback(element.scrollTop, true);
+      this.#update();
+    };
+    callback(element.scrollTop, false);
+    element.addEventListener("scroll", notify, { passive: true });
+    return () => element.removeEventListener("scroll", notify);
+  };
+}
+
+// src/components/tree/tree-selection.ts
+function uniqueIds(ids) {
+  return [...new Set(ids)];
+}
+function selectableIds(ids, disabledIds = new Set) {
+  return uniqueIds(ids).filter((id) => !disabledIds.has(id));
+}
+function selectionStateFor(selectedIds, targetIds, disabledIds = new Set) {
+  const targets = selectableIds(targetIds, disabledIds);
+  if (targets.length === 0)
+    return { checked: false, indeterminate: false };
+  const selected = new Set(selectedIds);
+  const selectedCount = targets.filter((id) => selected.has(id)).length;
+  return {
+    checked: selectedCount === targets.length,
+    indeterminate: selectedCount > 0 && selectedCount < targets.length
+  };
+}
+function selectIds(selectedIds, targetIds, disabledIds = new Set) {
+  const targets = selectableIds(targetIds, disabledIds);
+  if (targets.length === 0)
+    return [...selectedIds];
+  const existing = new Set(selectedIds);
+  const next = [...selectedIds];
+  for (const id of targets) {
+    if (!existing.has(id)) {
+      existing.add(id);
+      next.push(id);
+    }
+  }
+  return next;
+}
+function deselectIds(selectedIds, targetIds, disabledIds = new Set) {
+  const targetSet = new Set(selectableIds(targetIds, disabledIds));
+  if (targetSet.size === 0)
+    return [...selectedIds];
+  return selectedIds.filter((id) => !targetSet.has(id));
+}
+function toggleIndependentId(selectedIds, id, disabledIds = new Set) {
+  if (disabledIds.has(id))
+    return [...selectedIds];
+  return selectedIds.includes(id) ? selectedIds.filter((selectedId) => selectedId !== id) : [...selectedIds, id];
+}
+function toggleSelectionScope(selectedIds, targetIds, disabledIds = new Set) {
+  const targets = selectableIds(targetIds, disabledIds);
+  if (targets.length === 0)
+    return [...selectedIds];
+  const state = selectionStateFor(selectedIds, targets);
+  return state.checked ? deselectIds(selectedIds, targets, disabledIds) : selectIds(selectedIds, targets, disabledIds);
+}
+
+// src/components/tree/tree.svelte
+function Tree($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const generatedId = $5.props_id($$renderer2);
+    let {
+      selectionMode = "none",
+      checkboxSelection = false,
+      selectionBehavior = "independent",
+      selectedIds = [],
+      expandedIds = [],
+      ref = undefined,
+      items,
+      virtualized = false,
+      virtualizationEstimatedRowHeight = 36,
+      virtualizationOverscan = 4,
+      virtualizationHeight = "20rem",
+      virtualizedItem,
+      "aria-label": ariaLabel,
+      "aria-labelledby": ariaLabelledBy,
+      disableTypeahead = false,
+      id: idAttribute,
+      class: className,
+      style: styleAttribute,
+      selectionControls,
+      filterValue,
+      onfilterchange,
+      filterPlaceholder = "Search tree",
+      showSearch = false,
+      filterPredicate = defaultFilterPredicate,
+      onreorder,
+      children,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    function normalizeOptionalText(value) {
+      const trimmedValue = value?.trim();
+      return trimmedValue ? trimmedValue : undefined;
+    }
+    function defaultFilterPredicate(label, _id, query) {
+      return label.toLowerCase().includes(query.toLowerCase());
+    }
+    const registry = new TreeRegistry;
+    let focusedId = null;
+    let treeElement = null;
+    let filterInputElement = null;
+    let uncontrolledFilterValue = untrack(() => filterValue ?? "");
+    let filterStatusAnnouncement = "";
+    let filterStatusAnnouncementSequence = 0;
+    let filterStatusBusy = false;
+    let filterStatusTimer = null;
+    let expansionAnnouncement = "";
+    let expansionAnnouncementSequence = 0;
+    let dragAnnouncement = "";
+    let dragAnnouncementSequence = 0;
+    let dragController = null;
+    let latestDragPointerX = 0;
+    let latestDragPointerY = 0;
+    let dragScrollElement = null;
+    let dragScrollAnimationFrame = null;
+    let selectionAnchorId = null;
+    const typeaheadBuffer = new TypeaheadBuffer;
+    let hasWarnedNoLabel = false;
+    let hasWarnedVirtualizedChildren = false;
+    let hasWarnedVirtualizedWithoutItems = false;
+    const resolvedAriaLabel = $5.derived(() => normalizeOptionalText(ariaLabel));
+    const resolvedAriaLabelledBy = $5.derived(() => normalizeOptionalText(ariaLabelledBy));
+    const resolvedFilterPlaceholder = $5.derived(() => normalizeOptionalText(filterPlaceholder) ?? "Search tree");
+    const isFilterControlled = $5.derived(() => filterValue !== undefined);
+    const currentFilterValue = $5.derived(() => isFilterControlled() ? filterValue ?? "" : uncontrolledFilterValue);
+    const normalizedFilterValue = $5.derived(() => currentFilterValue().trim());
+    const filtering = $5.derived(() => normalizedFilterValue().length > 0);
+    const treeId = $5.derived(() => idAttribute ?? `${generatedId}-tree`);
+    const filterInputId = $5.derived(() => `${generatedId}-filter`);
+    const dragInstructionsId = $5.derived(() => `${generatedId}-drag-instructions`);
+    const isVirtualizedTree = $5.derived(() => virtualized && items != null);
+    const flattenedDataItems = $5.derived(() => flattenTreeDataItems(items ?? []));
+    const flattenedDataItemById = $5.derived(() => new Map(flattenedDataItems().map((item) => [item.id, item])));
+    const hasTreeChrome = $5.derived(() => selectionControls != null || showSearch || filtering() || onreorder != null);
+    const hasRegisteredItems = $5.derived(() => isVirtualizedTree() ? flattenedDataItems().length > 0 : registry.size > 0);
+    const activeVisibilityPredicate = $5.derived(() => {
+      if (!filtering())
+        return;
+      const query = normalizedFilterValue();
+      const predicate = filterPredicate;
+      return ({ id, label }) => predicate(label, id, query);
+    });
+    const activeDataVisibilityPredicate = $5.derived(() => {
+      if (!filtering())
+        return;
+      const query = normalizedFilterValue();
+      const predicate = filterPredicate;
+      return (item) => predicate(item.label, item.id, query);
+    });
+    const visibleDataItems = $5.derived(() => visibleTreeDataItems(flattenedDataItems(), expandedIds, activeDataVisibilityPredicate()));
+    const registryVisibleIds = $5.derived(() => registry.getVisible(expandedIds, activeVisibilityPredicate()));
+    const visibleIds = $5.derived(() => isVirtualizedTree() ? visibleDataItems().map((item) => item.id) : registryVisibleIds());
+    const hasNoFilterResults = $5.derived(() => filtering() && hasRegisteredItems() && visibleIds().length === 0);
+    const visibleIdSet = $5.derived(() => new SvelteSet(visibleIds()));
+    const expandableBranchIds = $5.derived(() => isVirtualizedTree() ? flattenedDataItems().filter((item) => item.branch).map((item) => item.id) : registry.getAllBranchIds({ bulkOnly: true }));
+    const expandableBranchCount = $5.derived(() => expandableBranchIds().length);
+    const hasExpandedItems = $5.derived(() => expandedIds.length > 0);
+    const initialFocusId = $5.derived(() => {
+      if (selectionMode !== "none" && selectedIds.length > 0) {
+        for (const id of visibleIds()) {
+          if (selectedIds.includes(id))
+            return id;
+        }
+      }
+      return visibleIds()[0] ?? null;
+    });
+    function visibleFocusCandidate(id) {
+      return id !== null && visibleIds().includes(id) ? id : null;
+    }
+    const effectiveFocusedId = $5.derived(() => {
+      return visibleFocusCandidate(focusedId) ?? visibleFocusCandidate(initialFocusId()) ?? visibleIds()[0] ?? null;
+    });
+    const virtualizer = new TreeVirtualizer({
+      getScrollElement: () => treeElement,
+      getCount: () => visibleDataItems().length,
+      getItemKey: (index) => visibleDataItems()[index]?.id ?? index,
+      getEstimatedSize: () => virtualizationEstimatedRowHeight,
+      getOverscan: () => virtualizationOverscan,
+      getInitialHeight: () => typeof virtualizationHeight === "number" ? virtualizationHeight : virtualizationEstimatedRowHeight * 10
+    });
+    const virtualItems = $5.derived(() => virtualizer.virtualItems);
+    const virtualizedActiveItem = $5.derived(() => effectiveFocusedId() ? flattenedDataItemById().get(effectiveFocusedId()) : undefined);
+    const virtualizedActiveDescendantId = $5.derived(() => isVirtualizedTree() && virtualizedActiveItem() ? virtualItemElementId(virtualizedActiveItem()) : undefined);
+    const virtualRows = $5.derived(() => {
+      const rows = [];
+      const renderedIndexes = new Set;
+      for (const virtualItem of virtualItems()) {
+        const item = visibleDataItems()[virtualItem.index];
+        if (item) {
+          renderedIndexes.add(virtualItem.index);
+          rows.push({ virtualItem, item });
+        }
+      }
+      if (effectiveFocusedId()) {
+        const focusedIndex = visibleIds().indexOf(effectiveFocusedId());
+        const focusedItem = visibleDataItems()[focusedIndex];
+        if (focusedItem && !renderedIndexes.has(focusedIndex)) {
+          const size = virtualizationEstimatedRowHeight;
+          rows.push({
+            item: focusedItem,
+            virtualItem: {
+              key: focusedItem.id,
+              index: focusedIndex,
+              start: focusedIndex * size,
+              end: (focusedIndex + 1) * size,
+              size,
+              lane: 0
+            }
+          });
+        }
+      }
+      rows.sort((a, b) => a.virtualItem.index - b.virtualItem.index);
+      return rows;
+    });
+    function virtualItemElementId(item) {
+      return `${treeId()}-item-${item.index}`;
+    }
+    function virtualizedHeightValue() {
+      return typeof virtualizationHeight === "number" ? `${virtualizationHeight}px` : virtualizationHeight;
+    }
+    function virtualizedTreeStyle() {
+      return `block-size: ${virtualizedHeightValue()}; overflow: auto; position: relative;`;
+    }
+    function treeStyle() {
+      const forwardedStyle = styleAttribute ?? undefined;
+      if (!isVirtualizedTree())
+        return forwardedStyle;
+      return forwardedStyle ? `${forwardedStyle}; ${virtualizedTreeStyle()}` : virtualizedTreeStyle();
+    }
+    function virtualizedSpacerStyle() {
+      return `block-size: ${virtualizer.totalSize}px; position: relative; inline-size: 100%;`;
+    }
+    function virtualizedRowStyle(start, size) {
+      return `position: absolute; inset-inline: 0; transform: translateY(${start}px); block-size: ${size}px;`;
+    }
+    function virtualizedItemExpanded(item) {
+      return expandedIds.includes(item.id) || filtering() && item.branch && visibleDataItems().some((visibleItem) => visibleItem.id !== item.id && visibleItem.ancestorIds.includes(item.id));
+    }
+    function virtualizedFilterForcedOpen(item) {
+      return item.branch && filtering() && !expandedIds.includes(item.id) && visibleDataItems().some((visibleItem) => visibleItem.id !== item.id && visibleItem.ancestorIds.includes(item.id));
+    }
+    function firstVisibleVirtualizedChildIndex(parentId) {
+      return visibleDataItems().findIndex((item) => item.parentId === parentId);
+    }
+    function focusFirstVirtualizedChild(parentId) {
+      const index = firstVisibleVirtualizedChildIndex(parentId);
+      if (index !== -1)
+        focusVirtualIndex(index);
+    }
+    function focusNode(id) {
+      if (isVirtualizedTree()) {
+        const index = visibleIds().indexOf(id);
+        if (index !== -1)
+          focusVirtualIndex(index);
+        return;
+      }
+      focusedId = id;
+      registry.getNode(id)?.focus();
+    }
+    async function focusVirtualIndex(index) {
+      const id = visibleIds()[index];
+      if (!id)
+        return;
+      virtualizer.scrollToIndex(index, { align: "auto" });
+      await tick();
+      focusedId = id;
+      treeElement?.focus();
+    }
+    function announceExpansion(message) {
+      expansionAnnouncement = message;
+      expansionAnnouncementSequence += 1;
+    }
+    function announceDrag(message) {
+      dragAnnouncement = message;
+      dragAnnouncementSequence += 1;
+    }
+    function focusFallbackAfterUnregister(parentId) {
+      const currentVisibleIds = registry.getVisible(expandedIds, activeVisibilityPredicate());
+      const selectedVisibleId = selectionMode === "none" ? null : currentVisibleIds.find((id) => selectedIds.includes(id));
+      const fallbackId = (parentId && currentVisibleIds.includes(parentId) ? parentId : null) ?? selectedVisibleId ?? currentVisibleIds[0] ?? null;
+      if (fallbackId) {
+        focusNode(fallbackId);
+      } else {
+        focusedId = null;
+      }
+    }
+    function setExpandedInternal(id, next) {
+      if (next) {
+        if (!expandedIds.includes(id)) {
+          expandedIds = [...expandedIds, id];
+        }
+      } else {
+        expandedIds = expandedIds.filter((existing) => existing !== id);
+      }
+    }
+    function withExpandedIds(ids) {
+      const nextIds = [...expandedIds];
+      const seen = new Set(nextIds);
+      for (const id of ids) {
+        if (!seen.has(id)) {
+          seen.add(id);
+          nextIds.push(id);
+        }
+      }
+      return nextIds;
+    }
+    async function expandAll() {
+      if (isVirtualizedTree()) {
+        const nextIds = withExpandedIds(expandableBranchIds());
+        if (nextIds.length !== expandedIds.length) {
+          expandedIds = nextIds;
+          await tick();
+          announceExpansion("All items expanded.");
+        }
+        return;
+      }
+      let changed = false;
+      while (true) {
+        const nextIds = withExpandedIds(registry.getAllBranchIds({ bulkOnly: true }));
+        if (nextIds.length === expandedIds.length)
+          break;
+        expandedIds = nextIds;
+        changed = true;
+        await tick();
+      }
+      if (changed)
+        announceExpansion("All items expanded.");
+    }
+    function collapseAll() {
+      if (expandedIds.length === 0)
+        return;
+      expandedIds = [];
+      announceExpansion("All items collapsed.");
+    }
+    function expandOneLevel() {
+      const expandedIdSet = new Set(expandedIds);
+      const visibleBranchIds = isVirtualizedTree() ? visibleDataItems().filter((item) => item.branch && item.ancestorIds.every((id) => expandedIdSet.has(id))).map((item) => item.id) : visibleIds().filter((id) => registry.isBulkExpandableBranch(id) && registry.ancestorsOf(id).every((ancestorId) => expandedIdSet.has(ancestorId)));
+      const nextIds = withExpandedIds(visibleBranchIds);
+      if (nextIds.length === expandedIds.length)
+        return;
+      expandedIds = nextIds;
+      announceExpansion("One tree level expanded.");
+    }
+    function focusItem(id) {
+      if (!visibleIds().includes(id))
+        return;
+      focusNode(id);
+    }
+    async function expandToItem(id) {
+      if (isVirtualizedTree()) {
+        const item = flattenedDataItemById().get(id);
+        if (!item)
+          return;
+        const nextIds2 = withExpandedIds(item.ancestorIds);
+        if (nextIds2.length !== expandedIds.length) {
+          expandedIds = nextIds2;
+          await tick();
+        }
+        focusItem(id);
+        return;
+      }
+      if (!registry.getNode(id))
+        return;
+      const nextIds = withExpandedIds(registry.ancestorsOf(id));
+      if (nextIds.length !== expandedIds.length) {
+        expandedIds = nextIds;
+        await tick();
+      }
+      focusItem(id);
+    }
+    function scrollToRow(id, options = undefined) {
+      if (isVirtualizedTree()) {
+        const index = visibleIds().indexOf(id);
+        if (index !== -1) {
+          virtualizer.scrollToIndex(index, {
+            align: options?.block === "center" ? "center" : "auto",
+            behavior: options?.behavior === "smooth" ? "smooth" : "auto"
+          });
+        }
+        return;
+      }
+      registry.getNode(id)?.node.scrollIntoView(options ?? { block: "nearest" });
+    }
+    function disabledIdsFor(ids) {
+      const disabledIds = new Set;
+      for (const id of ids) {
+        if (isVirtualizedTree()) {
+          if (flattenedDataItemById().get(id)?.disabled)
+            disabledIds.add(id);
+        } else if (registry.getNode(id)?.disabled) {
+          disabledIds.add(id);
+        }
+      }
+      return disabledIds;
+    }
+    function checkboxSelectionActive() {
+      return checkboxSelection && selectionMode === "multiple";
+    }
+    function ariaCheckedForSelectionState(state) {
+      if (!checkboxSelectionActive())
+        return;
+      if (state.indeterminate)
+        return "mixed";
+      return state.checked ? "true" : "false";
+    }
+    function selectionTargetsFor(id) {
+      if (isVirtualizedTree()) {
+        const item = flattenedDataItemById().get(id);
+        if (!item)
+          return [];
+        return [id, ...descendantTreeDataIds(flattenedDataItems(), id)];
+      }
+      const node = registry.getNode(id);
+      if (!node)
+        return [];
+      const explicitScopeIds = node.selectionScopeIds?.();
+      if (explicitScopeIds?.length)
+        return [...explicitScopeIds];
+      return [id, ...registry.descendantsOf(id)];
+    }
+    function childDataItemIds(parentId) {
+      return visibleDataItems().filter((item) => item.parentId === parentId).map((item) => item.id);
+    }
+    function selectionTargetsForChildren(parentId, includeDescendants) {
+      const childIds = isVirtualizedTree() ? childDataItemIds(parentId) : registry.childrenOf(parentId);
+      if (!includeDescendants)
+        return childIds;
+      const targets = [];
+      for (const childId of childIds) {
+        targets.push(...selectionTargetsFor(childId));
+      }
+      return [...new Set(targets)];
+    }
+    function selectionStateForId(id) {
+      const targets = selectionBehavior === "cascade" ? selectionTargetsFor(id) : [id];
+      const aggregateDisabledIds = disabledIdsFor(targets.filter((targetId) => targetId !== id));
+      return selectionStateFor(selectedIds, targets, aggregateDisabledIds);
+    }
+    function applySelectionScope(targets, next = undefined) {
+      const disabledIds = disabledIdsFor(targets);
+      selectedIds = next === true ? selectIds(selectedIds, targets, disabledIds) : next === false ? deselectIds(selectedIds, targets, disabledIds) : toggleSelectionScope(selectedIds, targets, disabledIds);
+    }
+    function toggleSelectionScopeInternal(id) {
+      if (selectionMode !== "multiple")
+        return;
+      const disabled = isVirtualizedTree() ? flattenedDataItemById().get(id)?.disabled ?? true : registry.getNode(id)?.disabled ?? true;
+      if (disabled)
+        return;
+      if (selectionBehavior === "cascade") {
+        applySelectionScope(selectionTargetsFor(id));
+      } else {
+        selectedIds = toggleIndependentId(selectedIds, id, disabledIdsFor([id]));
+      }
+      selectionAnchorId = id;
+    }
+    function toggleSelectedInternal(id, event) {
+      const disabled = isVirtualizedTree() ? flattenedDataItemById().get(id)?.disabled ?? true : registry.getNode(id)?.disabled ?? true;
+      if (disabled)
+        return;
+      if (selectionMode === "none")
+        return;
+      const isShift = event?.shiftKey ?? false;
+      const isMeta = event ? event.metaKey || event.ctrlKey : false;
+      if (selectionMode === "single") {
+        selectedIds = selectedIds.includes(id) ? [] : [id];
+        selectionAnchorId = id;
+        return;
+      }
+      if (isShift && selectionAnchorId) {
+        const anchorVisible = visibleIds().includes(selectionAnchorId);
+        const anchor = anchorVisible ? selectionAnchorId : id;
+        if (!anchorVisible)
+          selectionAnchorId = id;
+        const anchorIndex = visibleIds().indexOf(anchor);
+        const targetIndex = visibleIds().indexOf(id);
+        const start = Math.min(anchorIndex, targetIndex);
+        const end = Math.max(anchorIndex, targetIndex);
+        const rangeIds = visibleIds().slice(start, end + 1).filter((rangeId) => {
+          if (isVirtualizedTree())
+            return !flattenedDataItemById().get(rangeId)?.disabled;
+          const rangeNode = registry.getNode(rangeId);
+          return rangeNode && !rangeNode.disabled;
+        });
+        selectedIds = rangeIds;
+      } else if (isMeta) {
+        selectedIds = toggleIndependentId(selectedIds, id);
+        selectionAnchorId = id;
+      } else {
+        if (selectionBehavior === "cascade") {
+          applySelectionScope(selectionTargetsFor(id));
+        } else {
+          selectedIds = toggleIndependentId(selectedIds, id);
+        }
+        selectionAnchorId = id;
+      }
+    }
+    function selectAll() {
+      if (selectionMode !== "multiple")
+        return;
+      const allVisibleTargets = visibleIds().flatMap((id) => {
+        const disabled = isVirtualizedTree() ? flattenedDataItemById().get(id)?.disabled ?? true : registry.getNode(id)?.disabled ?? true;
+        if (disabled)
+          return [];
+        return selectionBehavior === "cascade" ? selectionTargetsFor(id) : [id];
+      });
+      const disabledIds = disabledIdsFor(allVisibleTargets);
+      selectedIds = selectIds(selectionBehavior === "cascade" ? selectedIds : [], allVisibleTargets, disabledIds);
+      if (allVisibleTargets.length > 0)
+        selectionAnchorId = allVisibleTargets[0];
+    }
+    const treeRef = {
+      expandAll,
+      collapseAll,
+      expandOneLevel,
+      focusItem,
+      expandToItem,
+      scrollToRow
+    };
+    const context = {
+      get selectionMode() {
+        return selectionMode;
+      },
+      get selectionBehavior() {
+        return selectionBehavior;
+      },
+      get checkboxSelection() {
+        return checkboxSelection;
+      },
+      get multiselectable() {
+        return selectionMode === "multiple";
+      },
+      get typeaheadEnabled() {
+        return !disableTypeahead;
+      },
+      get expandedIds() {
+        return expandedIds;
+      },
+      get selectedIds() {
+        return selectedIds;
+      },
+      get focusedId() {
+        return effectiveFocusedId();
+      },
+      get filtering() {
+        return filtering();
+      },
+      get filterValue() {
+        return normalizedFilterValue();
+      },
+      get hasRegisteredItems() {
+        return hasRegisteredItems();
+      },
+      get expandableBranchCount() {
+        return expandableBranchCount();
+      },
+      get hasExpandedItems() {
+        return hasExpandedItems();
+      },
+      get dragController() {
+        return dragController;
+      },
+      get dragInstructionsId() {
+        return dragInstructionsId();
+      },
+      isExpanded(id) {
+        return expandedIds.includes(id);
+      },
+      isSelected(id) {
+        return selectedIds.includes(id);
+      },
+      isFocused(id) {
+        return effectiveFocusedId() === id;
+      },
+      positionInSet(id) {
+        const siblings = registry.siblingsOf(id).filter((siblingId) => visibleIdSet().has(siblingId));
+        const index = siblings.indexOf(id);
+        return index === -1 ? undefined : index + 1;
+      },
+      setSize(id) {
+        const siblings = registry.siblingsOf(id).filter((siblingId) => visibleIdSet().has(siblingId));
+        return siblings.length || undefined;
+      },
+      isVisible(id) {
+        return visibleIdSet().has(id);
+      },
+      hasVisibleDescendant(id) {
+        return registry.descendantsOf(id).some((descendantId) => visibleIdSet().has(descendantId));
+      },
+      matchesFilter(label, id) {
+        return filtering() && filterPredicate(label, id, normalizedFilterValue());
+      },
+      checkboxSelectionActive,
+      selectionStateFor: selectionStateForId,
+      toggleSelectionScope(id) {
+        toggleSelectionScopeInternal(id);
+      },
+      selectSelectionScope(parentId, next, includeDescendants) {
+        if (selectionMode !== "multiple")
+          return;
+        applySelectionScope(selectionTargetsForChildren(parentId, includeDescendants), next);
+      },
+      hasSelectableSelectionScope(parentId, includeDescendants) {
+        const targets = selectionTargetsForChildren(parentId, includeDescendants);
+        const disabledIds = disabledIdsFor(targets);
+        return targets.some((id) => !disabledIds.has(id));
+      },
+      selectionTargetsFor,
+      selectionTargetsForChildren,
+      setExpanded: setExpandedInternal,
+      expandAll,
+      collapseAll,
+      expandOneLevel,
+      focusItem,
+      expandToItem,
+      scrollToRow,
+      toggleSelected: toggleSelectedInternal,
+      register(node) {
+        const unregister = registry.register(node);
+        return () => {
+          unregister();
+          if (focusedId === node.id) {
+            focusFallbackAfterUnregister(node.parentId);
+          }
+        };
+      },
+      focusVisibleDelta(currentId, delta) {
+        const index = visibleIds().indexOf(currentId);
+        if (index === -1)
+          return;
+        const nextIndex = index + delta;
+        if (nextIndex < 0 || nextIndex >= visibleIds().length)
+          return;
+        focusNode(visibleIds()[nextIndex]);
+      },
+      canFocusVisibleDelta(currentId, delta) {
+        const index = visibleIds().indexOf(currentId);
+        if (index === -1)
+          return false;
+        const nextIndex = index + delta;
+        return nextIndex >= 0 && nextIndex < visibleIds().length;
+      },
+      focusFirstVisible() {
+        if (visibleIds().length > 0)
+          focusNode(visibleIds()[0]);
+      },
+      focusLastVisible() {
+        if (visibleIds().length > 0)
+          focusNode(visibleIds()[visibleIds().length - 1]);
+      },
+      focusParent(currentId) {
+        const parentId = registry.parentOf(currentId);
+        if (parentId)
+          focusNode(parentId);
+      },
+      focusFirstChild(currentId) {
+        const childId = registry.childrenOf(currentId).find((id) => visibleIdSet().has(id));
+        if (childId)
+          focusNode(childId);
+      },
+      handleTypeahead(char, currentId) {
+        if (disableTypeahead)
+          return;
+        const match = registry.typeaheadMatch(typeaheadBuffer.push(char), currentId, expandedIds, activeVisibilityPredicate());
+        if (match)
+          focusNode(match);
+      },
+      expandSiblings(currentId) {
+        const siblings = registry.siblingsOf(currentId);
+        const branchSiblings = siblings.filter((id) => {
+          const node = registry.getNode(id);
+          return node?.isBranch() && !expandedIds.includes(id);
+        });
+        if (branchSiblings.length > 0) {
+          expandedIds = [...expandedIds, ...branchSiblings];
+        }
+      },
+      notifyFocus(id) {
+        focusedId = id;
+      }
+    };
+    setTreeContextRaw(context);
+    setTreeItemParentContextRaw({ parentId: null, level: 1 });
+    function handleKeydown(event) {
+      if (isVirtualizedTree() && handleVirtualizedKeydown(event))
+        return;
+      if ((event.metaKey || event.ctrlKey) && event.key === "a") {
+        event.preventDefault();
+        selectAll();
+      }
+      if (event.key === "Escape" && dragController?.dragging) {
+        event.preventDefault();
+        dragController.cancel();
+      }
+    }
+    function currentVirtualIndex() {
+      const index = effectiveFocusedId() ? visibleIds().indexOf(effectiveFocusedId()) : -1;
+      return index === -1 ? 0 : index;
+    }
+    function focusVirtualDelta(delta) {
+      const nextIndex = currentVirtualIndex() + delta;
+      if (nextIndex < 0 || nextIndex >= visibleIds().length)
+        return;
+      focusVirtualIndex(nextIndex);
+    }
+    function applyVirtualizedShiftSelection(currentId, event) {
+      if (!currentId || !event.shiftKey || selectionMode !== "multiple")
+        return;
+      toggleSelectedInternal(currentId, event);
+    }
+    function expandVirtualizedSiblings(currentId) {
+      const currentItem = currentId ? flattenedDataItemById().get(currentId) : undefined;
+      if (!currentItem)
+        return;
+      const siblingBranchIds = flattenedDataItems().filter((item) => item.parentId === currentItem.parentId && item.branch).map((item) => item.id);
+      const nextIds = withExpandedIds(siblingBranchIds);
+      if (nextIds.length !== expandedIds.length)
+        expandedIds = nextIds;
+    }
+    function handleVirtualizedKeydown(event) {
+      if ((event.metaKey || event.ctrlKey) && event.key === "a") {
+        event.preventDefault();
+        selectAll();
+        return true;
+      }
+      const currentId = effectiveFocusedId();
+      const currentItem = currentId ? flattenedDataItemById().get(currentId) : undefined;
+      switch (event.key) {
+        case "ArrowDown":
+          event.preventDefault();
+          applyVirtualizedShiftSelection(currentId, event);
+          focusVirtualDelta(1);
+          return true;
+        case "ArrowUp":
+          event.preventDefault();
+          applyVirtualizedShiftSelection(currentId, event);
+          focusVirtualDelta(-1);
+          return true;
+        case "Home":
+          event.preventDefault();
+          focusVirtualIndex(0);
+          return true;
+        case "End":
+          event.preventDefault();
+          focusVirtualIndex(visibleIds().length - 1);
+          return true;
+        case "ArrowRight":
+          event.preventDefault();
+          if (!currentItem?.branch)
+            return true;
+          if (!virtualizedItemExpanded(currentItem)) {
+            setExpandedInternal(currentItem.id, true);
+          } else {
+            focusFirstVirtualizedChild(currentItem.id);
+          }
+          return true;
+        case "ArrowLeft":
+          event.preventDefault();
+          if (currentItem?.branch && expandedIds.includes(currentItem.id)) {
+            setExpandedInternal(currentItem.id, false);
+          } else if (currentItem?.parentId) {
+            focusNode(currentItem.parentId);
+          }
+          return true;
+        case "Enter":
+        case " ":
+          if (!currentItem)
+            return false;
+          event.preventDefault();
+          activateVirtualizedItemFromKeyboard(currentItem, event);
+          return true;
+        case "*":
+          event.preventDefault();
+          expandVirtualizedSiblings(currentId);
+          return true;
+        default:
+          return handleVirtualizedTypeahead(event);
+      }
+    }
+    function handleVirtualizedTypeahead(event) {
+      if (disableTypeahead || !isTypeaheadKey(event)) {
+        return false;
+      }
+      event.preventDefault();
+      const startIndex = currentVirtualIndex();
+      const match = findTypeaheadMatch(visibleDataItems().map((item, index) => ({ value: index, label: item.label, disabled: item.disabled })), typeaheadBuffer.push(event.key), startIndex);
+      if (match !== undefined)
+        focusVirtualIndex(match);
+      return true;
+    }
+    function updateFilterValue(next) {
+      if (!isFilterControlled())
+        uncontrolledFilterValue = next;
+      onfilterchange?.(next);
+    }
+    function handleFilterInput(event) {
+      const target = event.currentTarget;
+      updateFilterValue(target.value);
+    }
+    function handleFilterKeydown(event) {
+      if (event.key === "ArrowDown") {
+        event.preventDefault();
+        const firstVisibleId = visibleIds()[0];
+        if (firstVisibleId)
+          focusNode(firstVisibleId);
+        return;
+      }
+      if (event.key === "Escape" && currentFilterValue().length > 0) {
+        event.preventDefault();
+        event.stopPropagation();
+        updateFilterValue("");
+        filterInputElement?.focus();
+      }
+    }
+    function pointerTargetElement(clientX, clientY, fallbackTarget) {
+      if (typeof document !== "undefined") {
+        const element = document.elementFromPoint(clientX, clientY);
+        if (element instanceof HTMLElement)
+          return element;
+      }
+      return fallbackTarget instanceof HTMLElement ? fallbackTarget : null;
+    }
+    function updateDragTargetFromPointer(clientX, clientY, fallbackTarget) {
+      const element = pointerTargetElement(clientX, clientY, fallbackTarget);
+      if (!element)
+        return;
+      dragController?.setDropTarget(dragController.targetFromPointer(clientY, element));
+    }
+    function stopDragAutoscroll() {
+      if (dragScrollAnimationFrame !== null && typeof cancelAnimationFrame === "function") {
+        cancelAnimationFrame(dragScrollAnimationFrame);
+      }
+      dragScrollAnimationFrame = null;
+      dragScrollElement = null;
+    }
+    function scheduleDragAutoscroll() {
+      if (dragScrollAnimationFrame !== null || !dragController?.pointerDragging || !dragScrollElement || typeof requestAnimationFrame !== "function") {
+        return;
+      }
+      dragScrollAnimationFrame = requestAnimationFrame(() => {
+        dragScrollAnimationFrame = null;
+        const tree = dragScrollElement;
+        if (!dragController?.pointerDragging || !tree)
+          return;
+        const rect = tree.getBoundingClientRect();
+        const edge = 32;
+        const speed = 8;
+        const previousScrollTop = tree.scrollTop;
+        if (latestDragPointerY - rect.top < edge) {
+          tree.scrollTop -= speed;
+        } else if (rect.bottom - latestDragPointerY < edge) {
+          tree.scrollTop += speed;
+        }
+        if (tree.scrollTop === previousScrollTop)
+          return;
+        updateDragTargetFromPointer(latestDragPointerX, latestDragPointerY, tree);
+        scheduleDragAutoscroll();
+      });
+    }
+    function handlePointerMove(event) {
+      if (!dragController?.pointerDragging)
+        return;
+      event.preventDefault();
+      latestDragPointerX = event.clientX;
+      latestDragPointerY = event.clientY;
+      dragScrollElement = event.currentTarget;
+      updateDragTargetFromPointer(event.clientX, event.clientY, event.target);
+      scheduleDragAutoscroll();
+    }
+    function handlePointerUp(event) {
+      if (!dragController?.pointerDragging)
+        return;
+      event.preventDefault();
+      stopDragAutoscroll();
+      dragController.drop();
+    }
+    function handlePointerCancel() {
+      if (!dragController?.pointerDragging)
+        return;
+      stopDragAutoscroll();
+      dragController.cancel();
+    }
+    function handleVirtualizedItemClick(item, event) {
+      focusedId = item.id;
+      treeElement?.focus();
+      if (event.detail > 1)
+        return;
+      if (!item.disabled)
+        toggleSelectedInternal(item.id, event);
+      if (item.branch && !event.shiftKey && !event.metaKey && !event.ctrlKey) {
+        setExpandedInternal(item.id, !expandedIds.includes(item.id));
+      }
+    }
+    function handleVirtualizedDisclosureClick(item, event) {
+      event.stopPropagation();
+      focusedId = item.id;
+      treeElement?.focus();
+      setExpandedInternal(item.id, !expandedIds.includes(item.id));
+    }
+    function syncVirtualizedCheckboxElement(element, id) {
+      const state = selectionStateForId(id);
+      element.checked = state.checked;
+      element.indeterminate = state.indeterminate && !state.checked;
+    }
+    function handleVirtualizedCheckboxClick(item, event) {
+      event.stopPropagation();
+      focusedId = item.id;
+      treeElement?.focus();
+      toggleSelectionScopeInternal(item.id);
+      const checkbox = event.currentTarget;
+      if (checkbox instanceof HTMLInputElement) {
+        syncVirtualizedCheckboxElement(checkbox, item.id);
+      }
+    }
+    function activateVirtualizedItemFromKeyboard(item, event) {
+      if (item.branch && event.key === "Enter") {
+        setExpandedInternal(item.id, !expandedIds.includes(item.id));
+        if (checkboxSelectionActive())
+          return;
+      }
+      if (checkboxSelectionActive()) {
+        toggleSelectionScopeInternal(item.id);
+      } else {
+        toggleSelectedInternal(item.id, event);
+      }
+    }
+    function handleVirtualizedItemKeydown(item, event) {
+      if (event.key !== "Enter" && event.key !== " ")
+        return;
+      event.preventDefault();
+      event.stopPropagation();
+      focusedId = item.id;
+      treeElement?.focus();
+      activateVirtualizedItemFromKeyboard(item, event);
+    }
+    function virtualizedRows($$renderer3) {
+      $$renderer3.push(`<div class="cinder-tree__virtual-spacer"${$5.attr_style(virtualizedSpacerStyle())}><!--[-->`);
+      const each_array = $5.ensure_array_like(virtualRows());
+      for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+        let row = each_array[$$index];
+        const virtualItem = row.virtualItem;
+        const item = row.item;
+        const itemSelectionState = selectionStateForId(item.id);
+        $$renderer3.push(`<div${$5.attr("id", virtualItemElementId(item))} role="treeitem" class="cinder-tree-item cinder-tree-item--virtual"${$5.attr("aria-level", item.level)}${$5.attr("aria-expanded", item.branch ? virtualizedItemExpanded(item) : undefined)}${$5.attr("aria-selected", selectionMode === "none" || checkboxSelectionActive() ? undefined : selectedIds.includes(item.id))}${$5.attr("aria-checked", ariaCheckedForSelectionState(itemSelectionState))}${$5.attr("aria-disabled", item.disabled || undefined)}${$5.attr("aria-setsize", item.setSize)}${$5.attr("aria-posinset", item.posInSet)}${$5.attr("aria-label", item.label)} tabindex="-1"${$5.attr("data-cinder-tree-item-id", item.id)}${$5.attr("data-cinder-expanded", item.branch && virtualizedItemExpanded(item) ? "" : undefined)}${$5.attr("data-cinder-selected", selectedIds.includes(item.id) ? "" : undefined)}${$5.attr("data-cinder-disabled", item.disabled ? "" : undefined)}${$5.attr("data-cinder-focused", effectiveFocusedId() === item.id ? "" : undefined)}${$5.attr("data-cinder-virtual-index", virtualItem.index)}${$5.attr_style(virtualizedRowStyle(virtualItem.start, virtualItem.size))}><div class="cinder-tree-item__row"${$5.attr_style(`padding-inline-start: ${item.level * 1.25}rem;`)}>`);
+        if (item.branch && !virtualizedFilterForcedOpen(item)) {
+          $$renderer3.push("<!--[0-->");
+          $$renderer3.push(`<button type="button" class="cinder-tree-item__disclosure"${$5.attr("aria-label", `${virtualizedItemExpanded(item) ? "Collapse" : "Expand"} ${item.label}`)}${$5.attr("aria-expanded", virtualizedItemExpanded(item))} tabindex="-1"><span aria-hidden="true"></span></button>`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<span class="cinder-tree-item__disclosure-spacer" aria-hidden="true"></span>`);
+        }
+        $$renderer3.push(`<!--]--> `);
+        if (checkboxSelectionActive()) {
+          $$renderer3.push("<!--[0-->");
+          $$renderer3.push(`<input type="checkbox" class="cinder-tree-item__checkbox"${$5.attr("checked", itemSelectionState.checked, true)}${$5.attr("disabled", item.disabled, true)} tabindex="-1" aria-hidden="true"/>`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+        }
+        $$renderer3.push(`<!--]--> `);
+        if (virtualizedItem) {
+          $$renderer3.push("<!--[0-->");
+          virtualizedItem($$renderer3, {
+            item,
+            expanded: virtualizedItemExpanded(item),
+            selected: selectedIds.includes(item.id),
+            focused: effectiveFocusedId() === item.id
+          });
+          $$renderer3.push(`<!---->`);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<span class="cinder-tree-item__label cinder-_truncate">${$5.escape(item.label)}</span>`);
+        }
+        $$renderer3.push(`<!--]--></div></div>`);
+      }
+      $$renderer3.push(`<!--]--></div>`);
+    }
+    function treeBody($$renderer3) {
+      $$renderer3.push(`<div${$5.attributes({
+        ...rest,
+        id: treeId(),
+        role: "tree",
+        tabindex: isVirtualizedTree() ? 0 : -1,
+        class: $5.clsx(classNames("cinder-tree", className)),
+        style: treeStyle(),
+        "aria-label": resolvedAriaLabel(),
+        "aria-labelledby": resolvedAriaLabelledBy(),
+        "aria-activedescendant": virtualizedActiveDescendantId(),
+        "aria-multiselectable": selectionMode === "multiple" ? true : undefined,
+        "aria-busy": filterStatusBusy || undefined,
+        "data-cinder-checkbox-selection": checkboxSelectionActive() ? "" : undefined,
+        "data-cinder-virtualized": isVirtualizedTree() ? "" : undefined
+      })}>`);
+      if (isVirtualizedTree()) {
+        $$renderer3.push("<!--[0-->");
+        virtualizedRows($$renderer3);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        children?.($$renderer3);
+        $$renderer3.push(`<!---->`);
+      }
+      $$renderer3.push(`<!--]--></div>`);
+    }
+    if (hasTreeChrome()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="cinder-tree-root">`);
+      if (showSearch) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-tree__filter"><label class="cinder-sr-only"${$5.attr("for", filterInputId())}>${$5.escape(resolvedFilterPlaceholder())}</label> <input${$5.attr("id", filterInputId())} class="cinder-tree__filter-input" type="search"${$5.attr("value", currentFilterValue())}${$5.attr("placeholder", resolvedFilterPlaceholder())}${$5.attr("aria-label", resolvedFilterPlaceholder())}${$5.attr("aria-controls", treeId())} autocomplete="off" autocorrect="off"${$5.attr("spellcheck", false)}/></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (selectionControls) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-tree__selection-controls">`);
+        selectionControls($$renderer2);
+        $$renderer2.push(`<!----></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (onreorder) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div${$5.attr("id", dragInstructionsId())} class="cinder-sr-only">Press Control Shift Space to lift the focused item, or Space from the reorder handle. Use
+        arrow keys to move. Press Space to drop, Escape to cancel.</div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      treeBody($$renderer2);
+      $$renderer2.push(`<!----> `);
+      if (hasNoFilterResults()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-tree__empty" role="none">No results</div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> `);
+      _visually_hidden_live_region($$renderer2, {
+        message: filterStatusAnnouncement,
+        announcementSequence: filterStatusAnnouncementSequence,
+        priority: "polite"
+      });
+      $$renderer2.push(`<!----> `);
+      if (onreorder) {
+        $$renderer2.push("<!--[0-->");
+        _visually_hidden_live_region($$renderer2, {
+          message: dragAnnouncement,
+          announcementSequence: dragAnnouncementSequence,
+          priority: "assertive"
+        });
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      treeBody($$renderer2);
+    }
+    $$renderer2.push(`<!--]--> `);
+    _visually_hidden_live_region($$renderer2, {
+      message: expansionAnnouncement,
+      announcementSequence: expansionAnnouncementSequence,
+      priority: "polite"
+    });
+    $$renderer2.push(`<!---->`);
+    $5.bind_props($$props, { selectedIds, expandedIds, ref });
+  });
+}
+
+// src/components/tree/index.ts
+var Tree2 = Object.assign(Tree, {
+  ExpandAll: Tree_expand_all,
+  Item: Tree_item,
+  SelectAll: Tree_select_all
+});
+var tree_default = Tree2;
+export { Tree2 as Tree, tree_default };
+
+//# debugId=D062E69585CE298864756E2164756E21