@aussieljk/forkbook 0.0.1-8 → 0.0.1-9

package/dist/_browser-chunks/chunk-NPNIBOPF.js

@@ -0,0 +1,18 @@
+import {
+  formatErrorMessage_default
+} from "./chunk-XTQCLWVH.js";
+
+// ../../node_modules/@base-ui/react/toolbar/root/ToolbarRootContext.mjs
+import * as React from "react";
+var ToolbarRootContext = React.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ToolbarRootContext.displayName = "ToolbarRootContext");
+function useToolbarRootContext(optional) {
+  let context = React.useContext(ToolbarRootContext);
+  if (context === void 0 && !optional)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ToolbarRootContext is missing. Toolbar parts must be placed within <Toolbar.Root>." : formatErrorMessage_default(69));
+  return context;
+}
+
+export {
+  useToolbarRootContext
+};

package/dist/_browser-chunks/{chunk-YYWKZ7O3.js → chunk-NTUHL5NS.js}

@@ -1,6 +1,9 @@
 import {
   PARAM_KEY
 } from "./chunk-ENKK74N4.js";
+import {
+  entryUrlPath
+} from "./chunk-C5TKXHTM.js";
 import {
   global
 } from "./chunk-6AKCRYVX.js";
@@ -19,8 +22,8 @@ function parseQuery(queryString) {
   return query;
 }
 var navigate = (params) => addons.getChannel().emit(SELECT_STORY, params), generateStoryUrl = (title, name) => {
-  let { location } = document, query = parseQuery(location.search), existingId = query.id ?? query.path?.match(/^\/story\/(.+)$/)?.[1], titleToLink = title || existingId?.split("--", 2)[0] || "", path = `/story/${toId(titleToLink, name)}`, sbPath = location.pathname.replace(/iframe\.html$/, "");
-  return `${location.origin + sbPath}?${Object.entries({ path }).map((item) => `${item[0]}=${item[1]}`).join("&")}`;
+  let { location } = document, query = parseQuery(location.search), existingId = query.id ?? query.path?.match(/^\/story\/(.+)$/)?.[1], titleToLink = title || existingId?.split("--", 2)[0] || "", urlPath = title && entryUrlPath({ title, name }) || `/_story/${toId(titleToLink, name)}`, sbPath = location.pathname.replace(/iframe\.html$/, "");
+  return `${location.origin + sbPath}${urlPath.slice(1)}`;
 }, hrefTo = (title, name) => new Promise((resolve) => {
   resolve(generateStoryUrl(title, name));
 }), hrefToSync = (title, name) => generateStoryUrl(title, name), valueOrCall = (args) => (value) => typeof value == "function" ? value(...args) : value, linkTo = (idOrTitle, nameInput) => (...args) => {

package/dist/_browser-chunks/chunk-OOETBSA7.js

@@ -0,0 +1,502 @@
+import {
+  ARROW_DOWN,
+  ARROW_LEFT,
+  ARROW_RIGHT,
+  ARROW_UP,
+  COMPOSITE_KEYS,
+  CompositeRootContext,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  END,
+  HOME,
+  MODIFIER_KEYS,
+  error,
+  findNonDisabledListIndex,
+  getMaxListIndex,
+  getMinListIndex,
+  getTarget,
+  isIndexOutOfListBounds,
+  isListIndexDisabled,
+  isNativeInput,
+  scrollIntoViewIfNeeded,
+  useCompositeRootContext,
+  useDirection,
+  useIsoLayoutEffect,
+  useMergedRefs,
+  useRefWithInit,
+  useRenderElement,
+  useStableCallback
+} from "./chunk-XTQCLWVH.js";
+
+// ../../node_modules/@base-ui/utils/useControlled.mjs
+import * as React from "react";
+function useControlled({
+  controlled,
+  default: defaultProp,
+  name,
+  state = "value"
+}) {
+  let {
+    current: isControlled
+  } = React.useRef(controlled !== void 0), [valueState, setValue] = React.useState(() => defaultProp), value = isControlled && controlled !== void 0 ? controlled : valueState;
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      isControlled !== (controlled !== void 0) && error([`A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [state, name, controlled]);
+    let {
+      current: defaultValue
+    } = React.useRef(defaultProp);
+    React.useEffect(() => {
+      !isControlled && serializeToDevModeString(defaultValue) !== serializeToDevModeString(defaultProp) && error([`A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join(`
+`));
+    }, [defaultProp]);
+  }
+  let setValueIfUncontrolled = React.useCallback((newValue) => {
+    isControlled || setValue(newValue);
+  }, []);
+  return [value, setValueIfUncontrolled];
+}
+function serializeToDevModeString(input) {
+  let nextId = 0, seen = /* @__PURE__ */ new WeakMap();
+  try {
+    return JSON.stringify(input, function(key, value) {
+      if (!(key === "_owner" && this != null && typeof this == "object" && "$$typeof" in this)) {
+        if (typeof value == "bigint")
+          return `__bigint__:${value}`;
+        if (value !== null && typeof value == "object") {
+          let id = seen.get(value);
+          if (id !== void 0)
+            return `__object__:${id}`;
+          seen.set(value, nextId), nextId += 1;
+        }
+        return value;
+      }
+    }) ?? `__top__:${typeof input}`;
+  } catch {
+    return "__unserializable__";
+  }
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/list/useCompositeListItem.mjs
+import * as React3 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/list/CompositeListContext.mjs
+import * as React2 from "react";
+var CompositeListContext = React2.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  subscribeMapChange: () => () => {
+  },
+  nextIndexRef: {
+    current: 0
+  }
+});
+process.env.NODE_ENV !== "production" && (CompositeListContext.displayName = "CompositeListContext");
+function useCompositeListContext() {
+  return React2.useContext(CompositeListContext);
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/list/useCompositeListItem.mjs
+function useCompositeListItem(params = {}) {
+  let {
+    guess,
+    label,
+    metadata,
+    textRef,
+    index: externalIndex
+  } = params, {
+    register,
+    unregister,
+    subscribeMapChange,
+    nextIndexRef
+  } = useCompositeListContext(), indexRef = React3.useRef(-1), [internalIndex, setInternalIndex] = React3.useState(externalIndex == null && guess ? () => {
+    if (indexRef.current === -1) {
+      let newIndex = nextIndexRef.current;
+      nextIndexRef.current += 1, indexRef.current = newIndex;
+    }
+    return indexRef.current;
+  } : -1), index = externalIndex ?? internalIndex, componentRef = React3.useRef(null), ref = React3.useCallback((node) => {
+    let previousNode = componentRef.current;
+    previousNode && unregister(previousNode), componentRef.current = node, node && register(node, {
+      metadata: metadata ?? null,
+      index: externalIndex ?? null,
+      label,
+      textRef
+    });
+  }, [externalIndex, register, unregister, metadata, label, textRef]);
+  return useIsoLayoutEffect(() => {
+    if (externalIndex == null)
+      return subscribeMapChange((map) => {
+        let i = componentRef.current ? map.get(componentRef.current)?.index : null;
+        i != null && setInternalIndex(i);
+      });
+  }, [externalIndex, subscribeMapChange]), {
+    ref,
+    index
+  };
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/item/useCompositeItem.mjs
+import * as React4 from "react";
+function useCompositeItem(params = {}) {
+  let {
+    highlightItemOnHover,
+    highlightedIndex,
+    onHighlightedIndexChange
+  } = useCompositeRootContext(), {
+    ref,
+    index
+  } = useCompositeListItem(params), isHighlighted = highlightedIndex === index, itemRef = React4.useRef(null), mergedRef = useMergedRefs(ref, itemRef);
+  return {
+    compositeProps: {
+      tabIndex: isHighlighted ? 0 : -1,
+      onFocus() {
+        onHighlightedIndexChange(index);
+      },
+      onMouseMove() {
+        let item = itemRef.current;
+        if (!highlightItemOnHover || !item)
+          return;
+        let disabled = item.hasAttribute("disabled") || item.ariaDisabled === "true";
+        !isHighlighted && !disabled && item.focus();
+      }
+    },
+    compositeRef: mergedRef,
+    index
+  };
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/list/CompositeList.mjs
+import * as React5 from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
+function CompositeList(props) {
+  let {
+    children,
+    elementsRef,
+    labelsRef,
+    onMapChange: onMapChangeProp
+  } = props, onMapChange = useStableCallback(onMapChangeProp), [, setMapTick] = React5.useState(0), listeners = useRefWithInit(createListeners).current, map = useRefWithInit(createMap).current, nextIndexRef = React5.useRef(0), isDirtyRef = React5.useRef(!0), itemsRef = React5.useRef(null), mutationObserverRef = React5.useRef(null), scheduleMapUpdate = useStableCallback(() => {
+    isDirtyRef.current || (isDirtyRef.current = !0, setMapTick((tick) => tick + 1));
+  }), register = useStableCallback((node, registration) => {
+    map.set(node, registration), scheduleMapUpdate();
+  }), unregister = useStableCallback((node) => {
+    map.delete(node), scheduleMapUpdate();
+  }), syncRefs = useStableCallback((items) => {
+    let nextMap = /* @__PURE__ */ new Map();
+    return elementsRef.current.length = 0, labelsRef && (labelsRef.current.length = 0), items.forEach((item) => {
+      nextMap.set(item.element, {
+        ...item.registration.metadata ?? {},
+        index: item.index
+      }), elementsRef.current[item.index] = item.element, labelsRef && (labelsRef.current[item.index] = item.registration.label !== void 0 ? item.registration.label : item.registration.textRef?.current?.textContent ?? item.element.textContent);
+    }), nextIndexRef.current = elementsRef.current.length, nextMap;
+  });
+  function observe(sortedNodes) {
+    if (mutationObserverRef.current?.disconnect(), mutationObserverRef.current = null, typeof MutationObserver != "function" || sortedNodes.length < 2)
+      return;
+    let mutationObserver = new MutationObserver((entries) => {
+      if (!hasMovedNode(entries))
+        return;
+      let previousConnectedNode = null;
+      for (let node of sortedNodes)
+        if (node.isConnected) {
+          if (previousConnectedNode && sortByDocumentPosition(previousConnectedNode, node) > 0) {
+            mutationObserver.disconnect(), scheduleMapUpdate();
+            return;
+          }
+          previousConnectedNode = node;
+        }
+    });
+    mutationObserverRef.current = mutationObserver;
+    let roots = /* @__PURE__ */ new Set();
+    for (let i = 1; i < sortedNodes.length; i += 1) {
+      let root = getCommonAncestor(sortedNodes[i - 1], sortedNodes[i]);
+      root && roots.add(root);
+    }
+    roots.forEach((root) => mutationObserver.observe(root, {
+      childList: !0
+    }));
+  }
+  let flush = useStableCallback(() => {
+    let [items, automaticNodes] = getCompositeListSnapshot(map), nextMap = syncRefs(items), previousItems = itemsRef.current, changed = !previousItems || previousItems.length !== items.length || items.some((item, index) => {
+      let previousItem = previousItems[index];
+      return item.index !== previousItem.index || item.element !== previousItem.element || item.registration.index !== previousItem.registration.index || item.registration.metadata !== previousItem.registration.metadata;
+    });
+    observe(automaticNodes), itemsRef.current = items, isDirtyRef.current = !1, changed && (listeners.forEach((listener) => listener(nextMap)), onMapChange(nextMap));
+  });
+  useIsoLayoutEffect(() => (!isDirtyRef.current && itemsRef.current && syncRefs(itemsRef.current), () => {
+    elementsRef.current = [], labelsRef && (labelsRef.current = []);
+  }), [elementsRef, labelsRef, syncRefs]), useIsoLayoutEffect(() => {
+    isDirtyRef.current && flush();
+  }), useIsoLayoutEffect(() => () => {
+    mutationObserverRef.current?.disconnect(), isDirtyRef.current = !0;
+  }, []);
+  let subscribeMapChange = useStableCallback((fn) => (listeners.add(fn), () => {
+    listeners.delete(fn);
+  })), contextValue = React5.useMemo(() => ({
+    register,
+    unregister,
+    subscribeMapChange,
+    nextIndexRef
+  }), [register, unregister, subscribeMapChange, nextIndexRef]);
+  return _jsx(CompositeListContext.Provider, {
+    value: contextValue,
+    children
+  });
+}
+function createMap() {
+  return /* @__PURE__ */ new Map();
+}
+function createListeners() {
+  return /* @__PURE__ */ new Set();
+}
+function getCompositeListSnapshot(map) {
+  let reservedIndices = /* @__PURE__ */ new Set(), items = [], automaticItems = [];
+  map.forEach((registration, node) => {
+    if (!node.isConnected)
+      return;
+    let index = registration.index, item = {
+      index: index ?? -1,
+      element: node,
+      registration
+    };
+    index === null ? automaticItems.push(item) : index >= 0 && (reservedIndices.add(index), items.push(item));
+  });
+  let nextAutomaticIndex = 0;
+  return automaticItems.sort((a, b) => sortByDocumentPosition(a.element, b.element)), automaticItems.forEach((item) => {
+    for (; reservedIndices.has(nextAutomaticIndex); )
+      nextAutomaticIndex += 1;
+    item.index = nextAutomaticIndex, items.push(item), nextAutomaticIndex += 1;
+  }), reservedIndices.size > 0 && items.sort((a, b) => a.index - b.index), [items, automaticItems.map((item) => item.element)];
+}
+function getCommonAncestor(firstNode, lastNode) {
+  let ancestor = firstNode.parentElement;
+  for (; ancestor && !ancestor.contains(lastNode); )
+    ancestor = ancestor.parentElement;
+  return ancestor;
+}
+function hasMovedNode(entries) {
+  for (let entry of entries)
+    for (let i = 0; i < entry.removedNodes.length; i += 1)
+      if (entry.removedNodes[i].isConnected)
+        return !0;
+  return !1;
+}
+function sortByDocumentPosition(a, b) {
+  return a.nextElementSibling === b ? -1 : b.nextElementSibling === a ? 1 : a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/constants.mjs
+var ACTIVE_COMPOSITE_ITEM = "data-composite-item-active";
+
+// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRoot.mjs
+import * as React7 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/root/useCompositeRoot.mjs
+import * as React6 from "react";
+
+// ../../node_modules/@base-ui/utils/isElementDisabled.mjs
+function isElementDisabled(element) {
+  return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/root/useCompositeRoot.mjs
+function useCompositeRoot(params) {
+  let {
+    loopFocus = !0,
+    orientation = "both",
+    grid,
+    onLoop,
+    direction,
+    highlightedIndex: externalHighlightedIndex,
+    onHighlightedIndexChange: externalSetHighlightedIndex,
+    rootRef: externalRef,
+    enableHomeAndEndKeys = !1,
+    stopEventPropagation,
+    disabledIndices,
+    modifierKeys = EMPTY_ARRAY
+  } = params, [internalHighlightedIndex, internalSetHighlightedIndex] = React6.useState(0), isGrid = grid != null, rootRef = React6.useRef(null), mergedRef = useMergedRefs(rootRef, externalRef), elementsRef = React6.useRef([]), hasSetDefaultIndexRef = React6.useRef(!1), highlightedElementRef = React6.useRef(null), highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex, onHighlightedIndexChange = useStableCallback((index, shouldScrollIntoView = !1) => {
+    if (highlightedElementRef.current = elementsRef.current[index] ?? null, (externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index), shouldScrollIntoView) {
+      let newActiveItem = elementsRef.current[index];
+      scrollIntoViewIfNeeded(rootRef.current, newActiveItem, direction, orientation);
+    }
+  }), onMapChange = useStableCallback((map) => {
+    if (map.size === 0)
+      return;
+    if (hasSetDefaultIndexRef.current) {
+      let elements = elementsRef.current, nextIndex = elements.indexOf(highlightedElementRef.current);
+      if (nextIndex === -1) {
+        let replacement = elements[highlightedIndex];
+        !replacement || isListIndexDisabled(elements, highlightedIndex, disabledIndices) ? onHighlightedIndexChange(getFallbackIndex(elements, disabledIndices)) : highlightedElementRef.current = replacement;
+      } else nextIndex !== highlightedIndex && onHighlightedIndexChange(nextIndex);
+      return;
+    }
+    hasSetDefaultIndexRef.current = !0;
+    let sortedElements = Array.from(map.keys()), activeItem = sortedElements.find((compositeElement) => compositeElement?.hasAttribute(ACTIVE_COMPOSITE_ITEM)) ?? null, activeIndex = activeItem ? map.get(activeItem)?.index ?? -1 : -1;
+    if (activeIndex !== -1)
+      onHighlightedIndexChange(activeIndex);
+    else if (isListIndexDisabled(sortedElements, highlightedIndex, disabledIndices)) {
+      let firstEnabledIndex = findNonDisabledListIndex(sortedElements, {
+        disabledIndices
+      });
+      isIndexOutOfListBounds(sortedElements, firstEnabledIndex) || onHighlightedIndexChange(firstEnabledIndex);
+    }
+    scrollIntoViewIfNeeded(rootRef.current, activeItem, direction, orientation);
+  });
+  useIsoLayoutEffect(() => {
+    if (disabledIndices == null || externalHighlightedIndex != null || !hasSetDefaultIndexRef.current)
+      return;
+    let elements = elementsRef.current;
+    if (isListIndexDisabled(elements, highlightedIndex, disabledIndices)) {
+      let firstEnabledIndex = findNonDisabledListIndex(elements, {
+        disabledIndices
+      });
+      isIndexOutOfListBounds(elements, firstEnabledIndex) || onHighlightedIndexChange(firstEnabledIndex);
+    }
+  }, [disabledIndices, externalHighlightedIndex, highlightedIndex, elementsRef, onHighlightedIndexChange]);
+  let wrappedOnLoop = useStableCallback((event, prevIndex, nextIndex) => onLoop ? onLoop(event, prevIndex, nextIndex, elementsRef) : nextIndex), onKeyDown = useStableCallback((event) => {
+    let isHomeOrEnd = event.key === HOME || event.key === END;
+    if (!COMPOSITE_KEYS.has(event.key) || !enableHomeAndEndKeys && isHomeOrEnd || isModifierKeySet(event, modifierKeys) || !rootRef.current)
+      return;
+    let isRtl = direction === "rtl", horizontalForwardKey = isRtl ? ARROW_LEFT : ARROW_RIGHT, horizontalBackwardKey = isRtl ? ARROW_RIGHT : ARROW_LEFT, forwardKey = orientation === "vertical" ? ARROW_DOWN : horizontalForwardKey, backwardKey = orientation === "vertical" ? ARROW_UP : horizontalBackwardKey, target = getTarget(event.nativeEvent);
+    if (target != null && isNativeInput(target) && !isElementDisabled(target)) {
+      let selectionStart = target.selectionStart, selectionEnd = target.selectionEnd, textContent = target.value;
+      if (selectionStart == null || event.shiftKey || selectionStart !== selectionEnd || event.key !== backwardKey && selectionStart < textContent.length || event.key !== forwardKey && selectionStart > 0)
+        return;
+    }
+    let nextIndex = highlightedIndex, minIndex = getMinListIndex(elementsRef, disabledIndices), maxIndex = getMaxListIndex(elementsRef, disabledIndices);
+    grid != null && (nextIndex = grid({
+      disabledIndices,
+      elementsRef,
+      event,
+      highlightedIndex,
+      loopFocus,
+      maxIndex,
+      minIndex,
+      onLoop: wrappedOnLoop,
+      orientation,
+      rtl: isRtl
+    }));
+    let isForwardKey = orientation !== "vertical" && event.key === horizontalForwardKey || orientation !== "horizontal" && event.key === ARROW_DOWN, isBackwardKey = orientation !== "vertical" && event.key === horizontalBackwardKey || orientation !== "horizontal" && event.key === ARROW_UP;
+    enableHomeAndEndKeys && (event.key === HOME ? nextIndex = minIndex : event.key === END && (nextIndex = maxIndex)), nextIndex === highlightedIndex && (isForwardKey || isBackwardKey) && (loopFocus && nextIndex === maxIndex && isForwardKey ? (nextIndex = minIndex, onLoop && (nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef))) : loopFocus && nextIndex === minIndex && isBackwardKey ? (nextIndex = maxIndex, onLoop && (nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef))) : nextIndex = findNonDisabledListIndex(elementsRef.current, {
+      startingIndex: nextIndex,
+      decrement: isBackwardKey,
+      disabledIndices
+    })), nextIndex !== highlightedIndex && !isIndexOutOfListBounds(elementsRef.current, nextIndex) && (stopEventPropagation && event.stopPropagation(), (isGrid || isHomeOrEnd || isForwardKey || isBackwardKey) && event.preventDefault(), onHighlightedIndexChange(nextIndex, !0), queueMicrotask(() => {
+      elementsRef.current[nextIndex]?.focus();
+    }));
+  });
+  return {
+    props: {
+      ref: mergedRef,
+      onFocus(event) {
+        let element = rootRef.current, target = getTarget(event.nativeEvent);
+        !element || target == null || !isNativeInput(target) || target.setSelectionRange(0, target.value.length);
+      },
+      onKeyDown
+    },
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    onMapChange,
+    relayKeyboardEvent: onKeyDown
+  };
+}
+function getFallbackIndex(elements, disabledIndices) {
+  let fallbackIndex = -1;
+  for (let index = 0; index < elements.length; index += 1) {
+    let element = elements[index];
+    if (!(!element || isListIndexDisabled(elements, index, disabledIndices))) {
+      if (element.hasAttribute(ACTIVE_COMPOSITE_ITEM))
+        return index;
+      fallbackIndex === -1 && (fallbackIndex = index);
+    }
+  }
+  return Math.max(fallbackIndex, 0);
+}
+function isModifierKeySet(event, ignoredModifierKeys) {
+  for (let key of MODIFIER_KEYS)
+    if (!ignoredModifierKeys.includes(key) && event.getModifierState(key))
+      return !0;
+  return !1;
+}
+
+// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRoot.mjs
+import { jsx as _jsx2 } from "react/jsx-runtime";
+function CompositeRoot(componentProps) {
+  let {
+    render,
+    className,
+    style,
+    refs = EMPTY_ARRAY,
+    props = EMPTY_ARRAY,
+    state = EMPTY_OBJECT,
+    stateAttributesMapping,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    orientation,
+    grid,
+    loopFocus,
+    onLoop,
+    enableHomeAndEndKeys,
+    onMapChange: onMapChangeProp,
+    stopEventPropagation = !0,
+    rootRef,
+    disabledIndices,
+    modifierKeys,
+    highlightItemOnHover = !1,
+    tag = "div",
+    ...elementProps
+  } = componentProps, direction = useDirection(), {
+    props: defaultProps,
+    highlightedIndex,
+    onHighlightedIndexChange,
+    elementsRef,
+    onMapChange: onMapChangeUnwrapped,
+    relayKeyboardEvent
+  } = useCompositeRoot({
+    grid,
+    loopFocus,
+    onLoop,
+    orientation,
+    highlightedIndex: highlightedIndexProp,
+    onHighlightedIndexChange: onHighlightedIndexChangeProp,
+    rootRef,
+    stopEventPropagation,
+    enableHomeAndEndKeys,
+    direction,
+    disabledIndices,
+    modifierKeys
+  }), element = useRenderElement(tag, componentProps, {
+    state,
+    ref: refs,
+    props: [defaultProps, ...props, elementProps],
+    stateAttributesMapping
+  }), contextValue = React7.useMemo(() => ({
+    highlightedIndex,
+    onHighlightedIndexChange,
+    highlightItemOnHover,
+    relayKeyboardEvent
+  }), [highlightedIndex, onHighlightedIndexChange, highlightItemOnHover, relayKeyboardEvent]);
+  return _jsx2(CompositeRootContext.Provider, {
+    value: contextValue,
+    children: _jsx2(CompositeList, {
+      elementsRef,
+      onMapChange: (newMap) => {
+        onMapChangeProp?.(newMap), onMapChangeUnwrapped(newMap);
+      },
+      children: element
+    })
+  });
+}
+
+export {
+  useControlled,
+  useCompositeListItem,
+  useCompositeItem,
+  CompositeList,
+  ACTIVE_COMPOSITE_ITEM,
+  CompositeRoot
+};

package/dist/_browser-chunks/{chunk-SK6S7ZXD.js → chunk-PFCGVFP6.js}

@@ -7,7 +7,7 @@ import {
 
 // src/addon-docs/blocks/components/SnippetWarning.tsx
 import { Button } from "@aussieljk/forkbook/internal/components";
-import { WarningIcon } from "@phosphor-icons/react";
+import { TriangleAlertIcon } from "lucide-react";
 
 // storybook-css:/home/runner/work/forkbook/forkbook/code/core/src/addon-docs/blocks/components/SnippetWarning.module.css
 var id = "core/src/addon-docs/blocks/components/SnippetWarning.module.css";
@@ -28,7 +28,7 @@ var SNIPPET_WARNING_LABEL = "Incomplete code snippet", SnippetWarning = ({ warni
     variant: "ghost",
     size: "small",
     padding: "small",
-    children: jsx(WarningIcon, {})
+    children: jsx(TriangleAlertIcon, {})
   }
 ) : null;
 
@@ -42,7 +42,7 @@ if (typeof document < "u" && !document.querySelector(`style[data-fb-css="${id2}"
   let style = document.createElement("style");
   style.setAttribute("data-fb-css", id2), style.textContent = ".fb-I61SDG-syntaxHighlighter{font-size:calc(var(--fb-size-s2) - 1px);border-radius:var(--fb-app-border-radius);margin:25px 0 40px;line-height:19px;box-shadow:0 1px 3px #0000001a;& pre.fb-I61SDG-prismjs{background:inherit;padding:20px}}.fb-I61SDG-snippetWarning{z-index:1;position:absolute;top:4px;right:4px}.fb-I61SDG-sourceWrapper{position:relative}.fb-I61SDG-skeletonWrapper{background:var(--fb-background-content);border-radius:var(--fb-app-border-radius);border:1px solid var(--fb-app-border-color);margin:25px 0 40px;padding:20px 20px 20px 22px;box-shadow:0 1px 3px #0000001a}:where([data-fb-theme=dark]){& .fb-I61SDG-syntaxHighlighter,& .fb-I61SDG-skeletonWrapper{box-shadow:0 2px 5px #0003}}.fb-I61SDG-skeletonPlaceholder{background:var(--fb-app-border-color);width:60%;height:17px;margin-top:1px;animation:1.5s ease-in-out infinite fb-I61SDG-glow;&:first-child{margin:0}}@keyframes fb-I61SDG-glow{0%,to{opacity:1}50%{opacity:.4}}", document.head.appendChild(style);
 }
-var Source_default = { skeletonPlaceholder: "fb-I61SDG-skeletonPlaceholder", syntaxHighlighter: "fb-I61SDG-syntaxHighlighter", glow: "fb-I61SDG-glow", prismjs: "fb-I61SDG-prismjs", snippetWarning: "fb-I61SDG-snippetWarning", sourceWrapper: "fb-I61SDG-sourceWrapper", skeletonWrapper: "fb-I61SDG-skeletonWrapper" };
+var Source_default = { snippetWarning: "fb-I61SDG-snippetWarning", prismjs: "fb-I61SDG-prismjs", syntaxHighlighter: "fb-I61SDG-syntaxHighlighter", sourceWrapper: "fb-I61SDG-sourceWrapper", skeletonPlaceholder: "fb-I61SDG-skeletonPlaceholder", glow: "fb-I61SDG-glow", skeletonWrapper: "fb-I61SDG-skeletonWrapper" };
 
 // src/addon-docs/blocks/components/Source.tsx
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";

package/dist/_browser-chunks/{chunk-H4ZHAXN3.js → chunk-V5U45XXZ.js}

@@ -1,6 +1,6 @@
 import {
   withLinks
-} from "./chunk-YYWKZ7O3.js";
+} from "./chunk-NTUHL5NS.js";
 import {
   __export
 } from "./chunk-IMSF75WX.js";