@aussieljk/forkbook 0.0.1-1 → 0.0.1-11

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

@@ -0,0 +1,669 @@
+import {
+  getCssDimensions,
+  inertValue,
+  useOpenChangeComplete,
+  useSyncExternalStore,
+  useTransitionStatus
+} from "./chunk-XKTORVEQ.js";
+import {
+  ACTIVE_COMPOSITE_ITEM,
+  CompositeList,
+  CompositeRoot,
+  useCompositeItem,
+  useCompositeListItem,
+  useControlled
+} from "./chunk-OOETBSA7.js";
+import {
+  EMPTY_ARRAY,
+  TransitionStatusDataAttributes_exports,
+  activeElement,
+  contains,
+  createChangeEventDetails,
+  formatErrorMessage_default,
+  getParentNode,
+  getWindow,
+  isHTMLElement,
+  isLastTraversableNode,
+  isReactVersionAtLeast,
+  ownerDocument,
+  reason_parts_exports,
+  transitionStatusMapping,
+  useBaseUiId,
+  useButton,
+  useCompositeRootContext,
+  useForcedRerendering,
+  useIsoLayoutEffect,
+  useRenderElement,
+  useStableCallback
+} from "./chunk-XTQCLWVH.js";
+import {
+  __export
+} from "./chunk-IMSF75WX.js";
+
+// ../../node_modules/@base-ui/react/tabs/index.parts.mjs
+var index_parts_exports = {};
+__export(index_parts_exports, {
+  Indicator: () => TabsIndicator,
+  List: () => TabsList,
+  Panel: () => TabsPanel,
+  Root: () => TabsRoot,
+  Tab: () => TabsTab
+});
+
+// ../../node_modules/@base-ui/react/tabs/root/TabsRoot.mjs
+import * as React2 from "react";
+
+// ../../node_modules/@base-ui/react/tabs/root/TabsRootContext.mjs
+import * as React from "react";
+var TabsRootContext = React.createContext(void 0);
+process.env.NODE_ENV !== "production" && (TabsRootContext.displayName = "TabsRootContext");
+function useTabsRootContext() {
+  let context = React.useContext(TabsRootContext);
+  if (context === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TabsRootContext is missing. Tabs parts must be placed within <Tabs.Root>." : formatErrorMessage_default(64));
+  return context;
+}
+
+// ../../node_modules/@base-ui/react/tabs/root/TabsRootDataAttributes.mjs
+var activationDirection = "data-activation-direction";
+
+// ../../node_modules/@base-ui/react/tabs/root/stateAttributesMapping.mjs
+var tabsStateAttributesMapping = {
+  tabActivationDirection: (dir) => ({
+    [activationDirection]: dir
+  })
+};
+
+// ../../node_modules/@base-ui/react/tabs/root/TabsRoot.mjs
+import { jsx as _jsx } from "react/jsx-runtime";
+var TabsRoot = React2.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    className,
+    defaultValue: defaultValueProp = 0,
+    onValueChange: onValueChangeProp,
+    orientation = "horizontal",
+    render,
+    value: valueProp,
+    style,
+    ...elementProps
+  } = componentProps, hasExplicitDefaultValueProp = componentProps.defaultValue !== void 0, tabPanelRefs = React2.useRef([]), [mountedTabPanels, setMountedTabPanels] = React2.useState(() => /* @__PURE__ */ new Map()), [value, setValue] = useControlled({
+    controlled: valueProp,
+    default: defaultValueProp,
+    name: "Tabs",
+    state: "value"
+  }), isControlled = valueProp !== void 0, [tabMap, setTabMap] = React2.useState(() => /* @__PURE__ */ new Map()), lastKnownTabElementRef = React2.useRef(void 0), getTabElementBySelectedValue = React2.useCallback((selectedValue) => findTabElement(tabMap, selectedValue), [tabMap]), [activationDirectionState, setActivationDirectionState] = React2.useState(() => ({
+    previousValue: value,
+    tabActivationDirection: "none"
+  })), {
+    previousValue,
+    tabActivationDirection: committedTabActivationDirection
+  } = activationDirectionState, tabActivationDirection = committedTabActivationDirection, directionComputationIncomplete = !1;
+  previousValue !== value && (tabActivationDirection = computeActivationDirection(previousValue, value, orientation, tabMap), directionComputationIncomplete = previousValue != null && value != null && getTabElementBySelectedValue(value) == null);
+  let nextPreviousValue = directionComputationIncomplete ? previousValue : value, shouldSyncActivationDirectionState = previousValue !== nextPreviousValue || committedTabActivationDirection !== tabActivationDirection;
+  useIsoLayoutEffect(() => {
+    shouldSyncActivationDirectionState && setActivationDirectionState({
+      previousValue: nextPreviousValue,
+      tabActivationDirection
+    });
+  }, [nextPreviousValue, shouldSyncActivationDirectionState, tabActivationDirection]);
+  let onValueChange = useStableCallback((newValue, eventDetails) => {
+    let activationDirection2 = computeActivationDirection(value, newValue, orientation, tabMap);
+    eventDetails.activationDirection = activationDirection2, onValueChangeProp?.(newValue, eventDetails), !eventDetails.isCanceled && setValue(() => newValue);
+  }), notifyAutomaticValueChange = useStableCallback((nextValue, reason) => {
+    onValueChangeProp?.(nextValue, createChangeEventDetails(reason, void 0, void 0, {
+      activationDirection: "none"
+    }));
+  }), registerMountedTabPanel = useStableCallback((panelValue, panelId) => (setMountedTabPanels((prev) => {
+    let next = new Map(prev);
+    return next.set(panelValue, panelId), next;
+  }), () => {
+    setMountedTabPanels((prev) => {
+      if (prev.get(panelValue) !== panelId)
+        return prev;
+      let next = new Map(prev);
+      return next.delete(panelValue), next;
+    });
+  })), getTabPanelIdByValue = React2.useCallback((tabValue) => mountedTabPanels.get(tabValue), [mountedTabPanels]), getTabIdByPanelValue = React2.useCallback((tabPanelValue) => {
+    for (let tabMetadata of tabMap.values())
+      if (tabPanelValue === tabMetadata.value)
+        return tabMetadata.id;
+  }, [tabMap]), tabsContextValue = React2.useMemo(() => ({
+    getTabElementBySelectedValue,
+    getTabIdByPanelValue,
+    getTabPanelIdByValue,
+    onValueChange,
+    orientation,
+    registerMountedTabPanel,
+    setTabMap,
+    tabActivationDirection,
+    value
+  }), [getTabElementBySelectedValue, getTabIdByPanelValue, getTabPanelIdByValue, onValueChange, orientation, registerMountedTabPanel, setTabMap, tabActivationDirection, value]), selectedTabMetadata = React2.useMemo(() => {
+    for (let tabMetadata of tabMap.values())
+      if (tabMetadata.value === value)
+        return tabMetadata;
+  }, [tabMap, value]), firstEnabledTabValue = React2.useMemo(() => {
+    for (let tabMetadata of tabMap.values())
+      if (!tabMetadata.disabled)
+        return tabMetadata.value;
+  }, [tabMap]), shouldNotifyInitialValueChangeRef = React2.useRef(!hasExplicitDefaultValueProp), initialDefaultValueRef = React2.useRef(defaultValueProp), shouldHonorDisabledDefaultValueRef = React2.useRef(hasExplicitDefaultValueProp), didRegisterTabsRef = React2.useRef(!1);
+  useIsoLayoutEffect(() => {
+    if (isControlled)
+      return;
+    function commitAutomaticValueChange(fallbackValue, fallbackReason) {
+      setValue(() => fallbackValue), setActivationDirectionState({
+        previousValue: fallbackValue,
+        tabActivationDirection: "none"
+      }), notifyAutomaticValueChange(fallbackValue, fallbackReason), shouldNotifyInitialValueChangeRef.current = !1;
+    }
+    if (tabMap.size === 0) {
+      didRegisterTabsRef.current && value !== null && !lastKnownTabElementRef.current?.isConnected && commitAutomaticValueChange(null, reason_parts_exports.missing);
+      return;
+    }
+    didRegisterTabsRef.current = !0, lastKnownTabElementRef.current = tabMap.keys().next().value;
+    let selectionIsDisabled = selectedTabMetadata?.disabled, selectionIsMissing = selectedTabMetadata == null && value !== null;
+    if (!selectionIsDisabled && value === initialDefaultValueRef.current && (shouldHonorDisabledDefaultValueRef.current = !1), shouldHonorDisabledDefaultValueRef.current && selectionIsDisabled && value === initialDefaultValueRef.current)
+      return;
+    let shouldNotifyInitialValueChange = shouldNotifyInitialValueChangeRef.current;
+    if (selectionIsDisabled || selectionIsMissing) {
+      let fallbackValue = firstEnabledTabValue ?? null;
+      if (value === fallbackValue) {
+        shouldNotifyInitialValueChangeRef.current = !1;
+        return;
+      }
+      let fallbackReason = reason_parts_exports.missing;
+      shouldNotifyInitialValueChange ? fallbackReason = reason_parts_exports.initial : selectionIsDisabled && (fallbackReason = reason_parts_exports.disabled), commitAutomaticValueChange(fallbackValue, fallbackReason);
+      return;
+    }
+    shouldNotifyInitialValueChange && selectedTabMetadata != null && (notifyAutomaticValueChange(value, reason_parts_exports.initial), shouldNotifyInitialValueChangeRef.current = !1);
+  }, [firstEnabledTabValue, isControlled, notifyAutomaticValueChange, selectedTabMetadata, setValue, tabMap, value]);
+  let element = useRenderElement("div", componentProps, {
+    state: {
+      orientation,
+      tabActivationDirection
+    },
+    ref: forwardedRef,
+    props: elementProps,
+    stateAttributesMapping: tabsStateAttributesMapping
+  });
+  return _jsx(TabsRootContext.Provider, {
+    value: tabsContextValue,
+    children: _jsx(CompositeList, {
+      elementsRef: tabPanelRefs,
+      children: element
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (TabsRoot.displayName = "TabsRoot");
+function findTabElement(tabMap, value) {
+  for (let [tabElement, tabMetadata] of tabMap.entries())
+    if (value === tabMetadata.value)
+      return tabElement;
+  return null;
+}
+function computeActivationDirection(oldValue, newValue, orientation, tabMap) {
+  if (oldValue == null || newValue == null)
+    return "none";
+  let [positionProp, backward, forward] = orientation === "horizontal" ? ["left", "left", "right"] : ["top", "up", "down"], oldTab = findTabElement(tabMap, oldValue), newTab = findTabElement(tabMap, newValue);
+  if (oldTab == null || newTab == null)
+    return oldTab !== newTab && (typeof oldValue == "number" || typeof oldValue == "string") && typeof oldValue == typeof newValue ? newValue > oldValue ? forward : backward : "none";
+  let oldPosition = oldTab.getBoundingClientRect()[positionProp], newPosition = newTab.getBoundingClientRect()[positionProp];
+  return newPosition < oldPosition ? backward : newPosition > oldPosition ? forward : "none";
+}
+
+// ../../node_modules/@base-ui/react/tabs/tab/TabsTab.mjs
+import * as React4 from "react";
+
+// ../../node_modules/@base-ui/react/tabs/list/TabsListContext.mjs
+import * as React3 from "react";
+var TabsListContext = React3.createContext(void 0);
+process.env.NODE_ENV !== "production" && (TabsListContext.displayName = "TabsListContext");
+function useTabsListContext() {
+  let context = React3.useContext(TabsListContext);
+  if (context === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TabsListContext is missing. TabsList parts must be placed within <Tabs.List>." : formatErrorMessage_default(65));
+  return context;
+}
+
+// ../../node_modules/@base-ui/react/tabs/tab/TabsTab.mjs
+var TabsTab = React4.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    className,
+    disabled = !1,
+    render,
+    value,
+    id: idProp,
+    nativeButton = !0,
+    style,
+    ...elementProps
+  } = componentProps, {
+    value: activeTabValue,
+    getTabPanelIdByValue,
+    onValueChange,
+    orientation,
+    tabActivationDirection
+  } = useTabsRootContext(), {
+    activateOnFocus,
+    registerTabResizeObserverElement,
+    tabsListElement
+  } = useTabsListContext(), {
+    highlightedIndex,
+    onHighlightedIndexChange
+  } = useCompositeRootContext(), id = useBaseUiId(idProp), tabMetadata = React4.useMemo(() => ({
+    disabled,
+    id,
+    value
+  }), [disabled, id, value]), {
+    compositeProps,
+    compositeRef,
+    index: index2
+    // hook is used instead of the CompositeItem component
+    // because the index is needed for Tab internals
+  } = useCompositeItem({
+    metadata: tabMetadata
+  }), active = value === activeTabValue, isNavigatingRef = React4.useRef(!1), unobserveTabElementRef = React4.useRef(null), observeTabElement = useStableCallback((element2) => {
+    unobserveTabElementRef.current?.(), unobserveTabElementRef.current = element2 ? registerTabResizeObserverElement(element2) : null;
+  });
+  useIsoLayoutEffect(() => {
+    if (isNavigatingRef.current) {
+      isNavigatingRef.current = !1;
+      return;
+    }
+    if (!(active && index2 > -1 && highlightedIndex !== index2))
+      return;
+    let listElement = tabsListElement;
+    if (listElement != null) {
+      let activeEl = activeElement(ownerDocument(listElement));
+      if (activeEl && contains(listElement, activeEl))
+        return;
+    }
+    disabled || onHighlightedIndexChange(index2);
+  }, [active, index2, highlightedIndex, onHighlightedIndexChange, disabled, tabsListElement]);
+  let {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton,
+    focusableWhenDisabled: !0
+  }), tabPanelId = getTabPanelIdByValue(value), isPressingRef = React4.useRef(!1), isMainButtonRef = React4.useRef(!1);
+  function activate(event) {
+    onValueChange(value, createChangeEventDetails(reason_parts_exports.none, event.nativeEvent, void 0, {
+      activationDirection: "none"
+    }));
+  }
+  function onClick(event) {
+    active || disabled || activate(event);
+  }
+  function onFocus(event) {
+    active || disabled || activateOnFocus && (!isPressingRef.current || // keyboard or touch focus
+    isMainButtonRef.current) && activate(event);
+  }
+  function onPointerDown(event) {
+    if (active || disabled)
+      return;
+    isPressingRef.current = !0, isMainButtonRef.current = event.button === 0;
+    let doc = ownerDocument(event.currentTarget);
+    function handlePointerEnd() {
+      isPressingRef.current = !1, isMainButtonRef.current = !1, doc.removeEventListener("pointerup", handlePointerEnd), doc.removeEventListener("pointercancel", handlePointerEnd);
+    }
+    doc.addEventListener("pointerup", handlePointerEnd), doc.addEventListener("pointercancel", handlePointerEnd);
+  }
+  return useRenderElement("button", componentProps, {
+    state: {
+      disabled,
+      active,
+      orientation,
+      tabActivationDirection
+    },
+    ref: [forwardedRef, buttonRef, compositeRef, observeTabElement],
+    props: [compositeProps, {
+      role: "tab",
+      "aria-controls": tabPanelId,
+      "aria-selected": active,
+      id,
+      onClick,
+      onFocus,
+      onPointerDown,
+      [ACTIVE_COMPOSITE_ITEM]: active ? "" : void 0,
+      onKeyDownCapture() {
+        isNavigatingRef.current = !0;
+      }
+    }, elementProps, getButtonProps],
+    stateAttributesMapping: tabsStateAttributesMapping
+  });
+});
+process.env.NODE_ENV !== "production" && (TabsTab.displayName = "TabsTab");
+
+// ../../node_modules/@base-ui/react/tabs/indicator/TabsIndicator.mjs
+import * as React8 from "react";
+
+// ../../node_modules/@base-ui/react/internals/PrehydrationScript.mjs
+import "react";
+
+// ../../node_modules/@base-ui/utils/hydration.mjs
+import * as React5 from "react";
+var emptySubscribe = () => () => {
+}, getTrue = () => !0, getFalse = () => !1;
+function useIsHydratedModern() {
+  return useSyncExternalStore(emptySubscribe, getTrue, getFalse);
+}
+function useIsHydratedLegacy() {
+  let [hydrated, setHydrated] = React5.useState(!1);
+  return React5.useEffect(() => {
+    setHydrated(!0);
+  }, []), hydrated;
+}
+var useIsHydrated = isReactVersionAtLeast(18) ? useIsHydratedModern : useIsHydratedLegacy;
+function useIsHydrating() {
+  return !useIsHydrated();
+}
+
+// ../../node_modules/@base-ui/react/internals/csp-context/CSPContext.mjs
+import * as React6 from "react";
+var CSPContext = React6.createContext(void 0);
+process.env.NODE_ENV !== "production" && (CSPContext.displayName = "CSPContext");
+var DEFAULT_CSP_CONTEXT_VALUE = {
+  disableStyleElements: !1
+};
+function useCSPContext() {
+  return React6.useContext(CSPContext) ?? DEFAULT_CSP_CONTEXT_VALUE;
+}
+
+// ../../node_modules/@base-ui/react/internals/PrehydrationScript.mjs
+import { jsx as _jsx2 } from "react/jsx-runtime";
+function PrehydrationScript(props) {
+  let {
+    script: script2
+  } = props, {
+    nonce
+  } = useCSPContext();
+  return useIsHydrating() ? _jsx2("script", {
+    nonce,
+    dangerouslySetInnerHTML: {
+      __html: script2
+    },
+    suppressHydrationWarning: !0
+  }) : null;
+}
+
+// ../../node_modules/@base-ui/react/utils/getElementTransform.mjs
+function getElementTransform(element, computedStyle) {
+  let transform = (computedStyle ?? getWindow(element).getComputedStyle(element)).transform, translateX = 0, translateY = 0, scale = 1;
+  if (transform && transform !== "none") {
+    let matrix = transform.match(/matrix(?:3d)?\(([^)]+)\)/);
+    if (matrix) {
+      let values = matrix[1].split(", ").map(parseFloat);
+      values.length === 6 ? (translateX = values[4], translateY = values[5], scale = Math.sqrt(values[0] * values[0] + values[1] * values[1])) : values.length === 16 && (translateX = values[12], translateY = values[13], scale = values[0]);
+    }
+  }
+  return {
+    x: translateX,
+    y: translateY,
+    scale
+  };
+}
+
+// ../../node_modules/@base-ui/react/tabs/indicator/TabsIndicatorCssVars.mjs
+var activeTabLeft = "--active-tab-left", activeTabRight = "--active-tab-right", activeTabTop = "--active-tab-top", activeTabBottom = "--active-tab-bottom", activeTabWidth = "--active-tab-width", activeTabHeight = "--active-tab-height";
+
+// ../../node_modules/@base-ui/react/tabs/indicator/TabsIndicator.mjs
+import { jsx as _jsx3, jsxs as _jsxs } from "react/jsx-runtime";
+var _PrehydrationScript, stateAttributesMapping = {
+  ...tabsStateAttributesMapping,
+  activeTabPosition: () => null,
+  activeTabSize: () => null
+}, MAX_LAYOUT_ROUNDING_ERROR = 2, TabsIndicator = React8.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    className,
+    render,
+    renderBeforeHydration = !1,
+    style: styleProp,
+    ...elementProps
+  } = componentProps, {
+    getTabElementBySelectedValue,
+    orientation,
+    tabActivationDirection,
+    value
+  } = useTabsRootContext(), {
+    tabsListElement,
+    registerIndicatorUpdateListener
+  } = useTabsListContext(), rerender = useForcedRerendering();
+  React8.useEffect(() => registerIndicatorUpdateListener(rerender), [registerIndicatorUpdateListener, rerender]);
+  let left = 0, right = 0, top = 0, bottom = 0, width = 0, height = 0, isTabSelected = !1;
+  if (value != null && tabsListElement != null) {
+    let activeTab = getTabElementBySelectedValue(value);
+    if (activeTab != null) {
+      isTabSelected = !0;
+      let {
+        width: computedWidth,
+        height: computedHeight
+      } = getCssDimensions(activeTab), {
+        width: tabListWidth,
+        height: tabListHeight
+      } = getCssDimensions(tabsListElement), tabRect = activeTab.getBoundingClientRect(), tabsListRect = tabsListElement.getBoundingClientRect(), scaleX = tabListWidth > 0 ? tabsListRect.width / tabListWidth : 1, scaleY = tabListHeight > 0 ? tabsListRect.height / tabListHeight : 1, layoutOffset = getLayoutOffset(activeTab, tabsListElement);
+      left = layoutOffset.left, top = layoutOffset.top;
+      let rectLeft = (tabRect.left - tabsListRect.left) / scaleX + tabsListElement.scrollLeft - tabsListElement.clientLeft, rectTop = (tabRect.top - tabsListRect.top) / scaleY + tabsListElement.scrollTop - tabsListElement.clientTop, tabTranslation = getActiveTabTranslation(activeTab);
+      Math.abs(rectLeft - tabTranslation.x - left) <= MAX_LAYOUT_ROUNDING_ERROR && Math.abs(rectTop - tabTranslation.y - top) <= MAX_LAYOUT_ROUNDING_ERROR && (left = rectLeft, top = rectTop), width = computedWidth, height = computedHeight, right = tabsListElement.scrollWidth - left - width, bottom = tabsListElement.scrollHeight - top - height;
+    }
+  }
+  let activeTabPosition = isTabSelected ? {
+    left,
+    right,
+    top,
+    bottom
+  } : null, activeTabSize = isTabSelected ? {
+    width,
+    height
+  } : null, style = isTabSelected ? {
+    [activeTabLeft]: `${left}px`,
+    [activeTabRight]: `${right}px`,
+    [activeTabTop]: `${top}px`,
+    [activeTabBottom]: `${bottom}px`,
+    [activeTabWidth]: `${width}px`,
+    [activeTabHeight]: `${height}px`
+  } : void 0, displayIndicator = isTabSelected && width > 0 && height > 0, element = useRenderElement("span", componentProps, {
+    state: {
+      orientation,
+      activeTabPosition,
+      activeTabSize,
+      tabActivationDirection
+    },
+    ref: forwardedRef,
+    props: [{
+      role: "presentation",
+      style,
+      hidden: !displayIndicator
+      // do not display the indicator before the layout is settled
+    }, elementProps, {
+      suppressHydrationWarning: !0
+    }],
+    stateAttributesMapping
+  });
+  return value == null ? null : _jsxs(React8.Fragment, {
+    children: [element, renderBeforeHydration && (_PrehydrationScript || (_PrehydrationScript = _jsx3(PrehydrationScript, {
+      script: ""
+    })))]
+  });
+});
+process.env.NODE_ENV !== "production" && (TabsIndicator.displayName = "TabsIndicator");
+function getLayoutOffset(element, ancestor) {
+  let elementOffset = getCumulativeOffset(element), ancestorOffset = getCumulativeOffset(ancestor), left = elementOffset.left - ancestorOffset.left - ancestor.clientLeft, top = elementOffset.top - ancestorOffset.top - ancestor.clientTop, node = getParentNode(element);
+  for (; isHTMLElement(node) && node !== ancestor && !isLastTraversableNode(node); )
+    left -= node.scrollLeft, top -= node.scrollTop, node = getParentNode(node);
+  return {
+    left,
+    top
+  };
+}
+function getCumulativeOffset(element) {
+  let left = 0, top = 0, currentElement = element;
+  for (; currentElement != null; ) {
+    left += currentElement.offsetLeft, top += currentElement.offsetTop;
+    let offsetParent = currentElement.offsetParent;
+    offsetParent != null && (left += offsetParent.clientLeft, top += offsetParent.clientTop), currentElement = offsetParent;
+  }
+  return {
+    left,
+    top
+  };
+}
+function getActiveTabTranslation(element) {
+  let computedStyle = getWindow(element).getComputedStyle(element), {
+    x,
+    y
+  } = getElementTransform(element, computedStyle), translateX = x, translateY = y, {
+    translate
+  } = computedStyle;
+  if (translate && translate !== "none") {
+    let parts = translate.split(" ");
+    translateX += resolveTranslateLength(parts[0], element.offsetWidth), translateY += resolveTranslateLength(parts[1], element.offsetHeight);
+  }
+  return {
+    x: translateX,
+    y: translateY
+  };
+}
+function resolveTranslateLength(value, referenceSize) {
+  if (!value)
+    return 0;
+  let numeric = parseFloat(value);
+  return Number.isFinite(numeric) ? value.endsWith("%") ? numeric / 100 * referenceSize : numeric : 0;
+}
+
+// ../../node_modules/@base-ui/react/tabs/panel/TabsPanel.mjs
+import * as React9 from "react";
+
+// ../../node_modules/@base-ui/react/tabs/panel/TabsPanelDataAttributes.mjs
+var index = "data-index";
+var startingStyle = TransitionStatusDataAttributes_exports.startingStyle, endingStyle = TransitionStatusDataAttributes_exports.endingStyle;
+
+// ../../node_modules/@base-ui/react/tabs/panel/TabsPanel.mjs
+var stateAttributesMapping2 = {
+  ...tabsStateAttributesMapping,
+  ...transitionStatusMapping
+}, TabsPanel = React9.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    className,
+    value,
+    render,
+    keepMounted = !1,
+    style,
+    ...elementProps
+  } = componentProps, {
+    value: selectedValue,
+    getTabIdByPanelValue,
+    orientation,
+    tabActivationDirection,
+    registerMountedTabPanel
+  } = useTabsRootContext(), id = useBaseUiId(), {
+    ref: listItemRef,
+    index: index2
+  } = useCompositeListItem(), open = value === selectedValue, {
+    mounted,
+    transitionStatus,
+    setMounted
+  } = useTransitionStatus(open), hidden = !mounted, correspondingTabId = getTabIdByPanelValue(value), state = {
+    hidden,
+    orientation,
+    tabActivationDirection,
+    transitionStatus
+  }, panelRef = React9.useRef(null), element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, listItemRef, panelRef],
+    props: [{
+      "aria-labelledby": correspondingTabId,
+      hidden,
+      id,
+      role: "tabpanel",
+      tabIndex: open ? 0 : -1,
+      inert: inertValue(!open),
+      // Computed key: a plain literal key fails the DOM-props excess property check.
+      [index]: index2
+    }, elementProps],
+    stateAttributesMapping: stateAttributesMapping2
+  });
+  return useOpenChangeComplete({
+    open,
+    ref: panelRef,
+    onComplete() {
+      open || setMounted(!1);
+    }
+  }), useIsoLayoutEffect(() => {
+    if (!(id == null || hidden && !keepMounted))
+      return registerMountedTabPanel(value, id);
+  }, [hidden, keepMounted, value, id, registerMountedTabPanel]), keepMounted || mounted ? element : null;
+});
+process.env.NODE_ENV !== "production" && (TabsPanel.displayName = "TabsPanel");
+
+// ../../node_modules/@base-ui/react/tabs/list/TabsList.mjs
+import * as React10 from "react";
+import { jsx as _jsx4 } from "react/jsx-runtime";
+var TabsList = React10.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    activateOnFocus = !1,
+    className,
+    loopFocus = !0,
+    render,
+    style,
+    ...elementProps
+  } = componentProps, {
+    orientation,
+    setTabMap,
+    tabActivationDirection
+  } = useTabsRootContext(), [highlightedTabIndex, setHighlightedTabIndex] = React10.useState(0), [tabsListElement, setTabsListElement] = React10.useState(null), indicatorUpdateListenersRef = React10.useRef(/* @__PURE__ */ new Set()), tabResizeObserverElementsRef = React10.useRef(/* @__PURE__ */ new Set()), resizeObserverRef = React10.useRef(null);
+  useIsoLayoutEffect(() => {
+    if (typeof ResizeObserver > "u")
+      return;
+    let resizeObserver = new ResizeObserver(() => {
+      indicatorUpdateListenersRef.current.forEach((listener) => {
+        listener();
+      });
+    });
+    return resizeObserverRef.current = resizeObserver, tabsListElement && resizeObserver.observe(tabsListElement), tabResizeObserverElementsRef.current.forEach((element) => {
+      resizeObserver.observe(element);
+    }), () => {
+      resizeObserver.disconnect(), resizeObserverRef.current = null;
+    };
+  }, [tabsListElement]);
+  let registerIndicatorUpdateListener = useStableCallback((listener) => (indicatorUpdateListenersRef.current.add(listener), () => {
+    indicatorUpdateListenersRef.current.delete(listener);
+  })), registerTabResizeObserverElement = useStableCallback((element) => (tabResizeObserverElementsRef.current.add(element), resizeObserverRef.current?.observe(element), () => {
+    tabResizeObserverElementsRef.current.delete(element), resizeObserverRef.current?.unobserve(element);
+  })), state = {
+    orientation,
+    tabActivationDirection
+  }, defaultProps = {
+    "aria-orientation": orientation === "vertical" ? "vertical" : void 0,
+    role: "tablist"
+  }, tabsListContextValue = React10.useMemo(() => ({
+    activateOnFocus,
+    registerIndicatorUpdateListener,
+    registerTabResizeObserverElement,
+    tabsListElement
+  }), [activateOnFocus, registerIndicatorUpdateListener, registerTabResizeObserverElement, tabsListElement]);
+  return _jsx4(TabsListContext.Provider, {
+    value: tabsListContextValue,
+    children: _jsx4(CompositeRoot, {
+      render,
+      className,
+      style,
+      state,
+      refs: [forwardedRef, setTabsListElement],
+      props: [defaultProps, elementProps],
+      stateAttributesMapping: tabsStateAttributesMapping,
+      highlightedIndex: highlightedTabIndex,
+      enableHomeAndEndKeys: !0,
+      loopFocus,
+      orientation,
+      onHighlightedIndexChange: setHighlightedTabIndex,
+      onMapChange: setTabMap,
+      disabledIndices: EMPTY_ARRAY
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (TabsList.displayName = "TabsList");
+
+export {
+  useCSPContext,
+  index_parts_exports
+};

package/dist/_browser-chunks/{chunk-YTIT5NA5.js → chunk-KYSD26D6.js}

@@ -1,6 +1,6 @@
 import {
   getChannel
-} from "./chunk-OD6IBQCC.js";
+} from "./chunk-N3NRW5XX.js";
 import {
   buildQueryState,
   toError
@@ -20,14 +20,14 @@ import {
   OpenServiceRemoteCommandUnhandledError,
   OpenServiceUnimplementedOperationError,
   OpenServiceValidationError
-} from "./chunk-6SXYJQST.js";
+} from "./chunk-76222HQR.js";
 import {
   isEqual
 } from "./chunk-B4AUNNU4.js";
 import {
   OpenServiceStaticSnapshotInvalidError,
   OpenServiceStaticSnapshotLoadError
-} from "./chunk-RSPAQWVJ.js";
+} from "./chunk-BNP234B4.js";
 
 // ../../node_modules/nanoid/index.browser.js
 var nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => (byte &= 63, byte < 36 ? id += byte.toString(36) : byte < 62 ? id += (byte - 26).toString(36).toUpperCase() : byte > 62 ? id += "-" : id += "_", id), "");