@ankhorage/zora 25.5.0 → 25.6.2

package/web-dist/chunks/Accordion-a6551mh4.js

@@ -0,0 +1,515 @@
+'use client';
+import {
+  getVisibleGridItems,
+  constrainViewport,
+  panViewport,
+  revealWorldRect,
+  worldToViewport,
+  zoomViewportAt
+} from "./Accordion-bz04casa.js";
+import {
+  require_cjs
+} from "./Accordion-xgpzh4wq.js";
+import {
+  __toESM
+} from "./Accordion-nh0cs9hq.js";
+
+// src/features/grid-view/adapters/inbound/GridView.tsx
+var import_react_native = __toESM(require_cjs(), 1);
+import React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function GridView2({
+  items,
+  contentWidth,
+  contentHeight,
+  width,
+  height,
+  viewport: controlledViewport,
+  defaultViewport,
+  viewportConstraints,
+  zoomLimits,
+  zoom = 1,
+  overscanPixels = 160,
+  focusedItemId,
+  revealPaddingPixels = 8,
+  interactionPolicy,
+  onViewportChange,
+  onVisibleItemIdsChange,
+  renderItem,
+  testID
+}) {
+  const [uncontrolledViewport, setUncontrolledViewport] = React.useState(() => createInitialViewport(width, height, zoom, defaultViewport));
+  const horizontalScrollRef = React.useRef(null);
+  const verticalScrollRef = React.useRef(null);
+  const gridRef = React.useRef(null);
+  const scrollPositionRef = React.useRef({ x: 0, y: 0 });
+  const pinchGestureRef = React.useRef(undefined);
+  const pinchMeasurementRef = React.useRef(0);
+  const pinchSessionRef = React.useRef(0);
+  const viewportOriginRef = React.useRef({ x: 0, y: 0 });
+  const focusRevealProposalRef = React.useRef(undefined);
+  const focusRevealViewportRef = React.useRef(undefined);
+  const [isPinching, setIsPinching] = React.useState(false);
+  const constraints = React.useMemo(() => viewportConstraints ?? createContentConstraints(contentWidth, contentHeight), [contentHeight, contentWidth, viewportConstraints]);
+  const sourceViewport = controlledViewport ?? uncontrolledViewport;
+  const viewport = React.useMemo(() => constrainViewport({ ...sourceViewport, height, width }, constraints), [constraints, height, sourceViewport, width]);
+  const viewportRef = React.useRef(viewport);
+  const visibleItems = React.useMemo(() => getVisibleGridItems(items, viewport, overscanPixels), [items, overscanPixels, viewport]);
+  const viewportVisibleIds = React.useMemo(() => getVisibleGridItems(visibleItems, viewport).map((item) => item.id), [viewport, visibleItems]);
+  const focusedItem = items.find((item) => item.id === focusedItemId);
+  const focusedItemHeight = focusedItem?.height;
+  const focusedItemIdForReveal = focusedItem?.id;
+  const focusedItemWidth = focusedItem?.width;
+  const focusedItemX = focusedItem?.x;
+  const focusedItemY = focusedItem?.y;
+  const previousVisibleIdsRef = React.useRef([]);
+  const uncontrolled = controlledViewport === undefined;
+  const interactive = interactionPolicy !== "passive";
+  const publish = React.useCallback((nextViewport) => {
+    if (areViewportsEqual(viewportRef.current, nextViewport))
+      return;
+    viewportRef.current = nextViewport;
+    if (uncontrolled)
+      setUncontrolledViewport(nextViewport);
+    onViewportChange?.(nextViewport);
+  }, [onViewportChange, uncontrolled]);
+  const publishRef = React.useRef(publish);
+  const pan = (displacement) => publish(panViewport(viewportRef.current, displacement, constraints));
+  const zoomAt = (focalPoint, factor) => publish(zoomViewportAt(viewportRef.current, focalPoint, {
+    pixelsPerUnitX: viewportRef.current.pixelsPerUnitX * factor,
+    pixelsPerUnitY: viewportRef.current.pixelsPerUnitY * factor
+  }, zoomLimits, constraints));
+  React.useEffect(() => {
+    viewportRef.current = viewport;
+  }, [viewport]);
+  React.useEffect(() => {
+    publishRef.current = publish;
+  }, [publish]);
+  const refreshViewportOrigin = React.useCallback(() => {
+    gridRef.current?.measureInWindow((x, y) => {
+      viewportOriginRef.current = { x, y };
+    });
+  }, []);
+  const measurePinchGesture = React.useCallback((touches, session, onMeasured) => {
+    const measurement = pinchMeasurementRef.current + 1;
+    pinchMeasurementRef.current = measurement;
+    gridRef.current?.measureInWindow((x, y) => {
+      if (measurement !== pinchMeasurementRef.current || session !== pinchSessionRef.current) {
+        return;
+      }
+      viewportOriginRef.current = { x, y };
+      onMeasured(getPinchGesture(touches, width, height, { x, y }));
+    });
+  }, [height, width]);
+  React.useLayoutEffect(() => {
+    refreshViewportOrigin();
+  }, [height, refreshViewportOrigin, width]);
+  React.useEffect(() => () => {
+    pinchMeasurementRef.current += 1;
+    pinchSessionRef.current += 1;
+  }, []);
+  React.useEffect(() => {
+    if (!onVisibleItemIdsChange)
+      return;
+    const previous = previousVisibleIdsRef.current;
+    if (previous.length === viewportVisibleIds.length && previous.every((id, index) => id === viewportVisibleIds.at(index))) {
+      return;
+    }
+    previousVisibleIdsRef.current = viewportVisibleIds;
+    onVisibleItemIdsChange(viewportVisibleIds);
+  }, [onVisibleItemIdsChange, viewportVisibleIds]);
+  React.useEffect(() => {
+    const position = createScrollMapping(viewport, constraints);
+    const nextPosition = {
+      x: position.horizontal.position,
+      y: position.vertical.position
+    };
+    if (areScrollPositionsEqual(scrollPositionRef.current, nextPosition))
+      return;
+    scrollPositionRef.current = nextPosition;
+    const animated = focusRevealViewportRef.current !== undefined && areViewportsEqual(viewport, focusRevealViewportRef.current);
+    horizontalScrollRef.current?.scrollTo({ animated, x: nextPosition.x });
+    verticalScrollRef.current?.scrollTo({ animated, y: nextPosition.y });
+    if (animated)
+      focusRevealViewportRef.current = undefined;
+  }, [constraints, viewport]);
+  React.useEffect(() => {
+    if (focusedItemHeight === undefined || focusedItemIdForReveal === undefined || focusedItemWidth === undefined || focusedItemX === undefined || focusedItemY === undefined) {
+      focusRevealProposalRef.current = undefined;
+      return;
+    }
+    const sourceViewport = viewportRef.current;
+    const revealed = revealWorldRect(sourceViewport, {
+      height: focusedItemHeight,
+      width: focusedItemWidth,
+      x: focusedItemX,
+      y: focusedItemY
+    }, revealPaddingPixels, constraints);
+    if (isRepeatedControlledFocusRevealProposal({
+      controlled: !uncontrolled,
+      focusedItemId: focusedItemIdForReveal,
+      previous: focusRevealProposalRef.current,
+      sourceViewport,
+      viewport: revealed
+    })) {
+      return;
+    }
+    focusRevealProposalRef.current = {
+      focusedItemId: focusedItemIdForReveal,
+      sourceViewport,
+      viewport: revealed
+    };
+    focusRevealViewportRef.current = areViewportsEqual(sourceViewport, revealed) ? undefined : revealed;
+    publishRef.current(revealed);
+  }, [
+    constraints,
+    focusedItemHeight,
+    focusedItemIdForReveal,
+    focusedItemWidth,
+    focusedItemX,
+    focusedItemY,
+    revealPaddingPixels,
+    uncontrolled
+  ]);
+  const scrollMapping = createScrollMapping(viewport, constraints);
+  const syncScrollPosition = () => {
+    const nextMapping = createScrollMapping(viewportRef.current, constraints);
+    const nextPosition = {
+      x: nextMapping.horizontal.position,
+      y: nextMapping.vertical.position
+    };
+    scrollPositionRef.current = nextPosition;
+    horizontalScrollRef.current?.scrollTo({ animated: false, x: nextPosition.x });
+    verticalScrollRef.current?.scrollTo({ animated: false, y: nextPosition.y });
+  };
+  return /* @__PURE__ */ jsxs(import_react_native.View, {
+    ref: gridRef,
+    accessibilityLabel: "Interactive grid viewport",
+    onLayout: refreshViewportOrigin,
+    onTouchEnd: () => {
+      const wasPinching = pinchGestureRef.current !== undefined;
+      pinchMeasurementRef.current += 1;
+      pinchSessionRef.current += 1;
+      pinchGestureRef.current = undefined;
+      setIsPinching(false);
+      if (wasPinching)
+        syncScrollPosition();
+    },
+    onTouchCancel: () => {
+      const wasPinching = pinchGestureRef.current !== undefined;
+      pinchMeasurementRef.current += 1;
+      pinchSessionRef.current += 1;
+      pinchGestureRef.current = undefined;
+      setIsPinching(false);
+      if (wasPinching)
+        syncScrollPosition();
+    },
+    onTouchMove: (event) => {
+      if (!interactive)
+        return;
+      measurePinchGesture([...event.nativeEvent.touches], pinchSessionRef.current, (pinch) => {
+        const previous = pinchGestureRef.current;
+        pinchGestureRef.current = pinch;
+        setIsPinching(pinch !== undefined);
+        if (!pinch || !previous)
+          return;
+        zoomAt(pinch.focalPoint, pinch.distance / previous.distance);
+      });
+    },
+    onTouchStart: (event) => {
+      const session = pinchSessionRef.current + 1;
+      pinchSessionRef.current = session;
+      measurePinchGesture([...event.nativeEvent.touches], session, (pinch) => {
+        pinchGestureRef.current = pinch;
+        setIsPinching(pinch !== undefined);
+      });
+    },
+    style: { height, overflow: "hidden", width },
+    testID,
+    children: [
+      /* @__PURE__ */ jsx(import_react_native.ScrollView, {
+        ref: horizontalScrollRef,
+        testID: testID ? `${testID}-horizontal-scroll` : undefined,
+        horizontal: true,
+        scrollEnabled: interactive && !isPinching,
+        scrollEventThrottle: 16,
+        showsHorizontalScrollIndicator: true,
+        style: { height, width },
+        onScroll: (event) => {
+          if (pinchGestureRef.current)
+            return;
+          const { x } = event.nativeEvent.contentOffset;
+          const displacement = x - scrollPositionRef.current.x;
+          scrollPositionRef.current = { ...scrollPositionRef.current, x };
+          if (displacement !== 0)
+            pan({ x: -displacement, y: 0 });
+        },
+        children: /* @__PURE__ */ jsx(import_react_native.ScrollView, {
+          ref: verticalScrollRef,
+          testID: testID ? `${testID}-vertical-scroll` : undefined,
+          scrollEnabled: interactive && !isPinching,
+          scrollEventThrottle: 16,
+          showsVerticalScrollIndicator: true,
+          style: { height, width: scrollMapping.horizontal.contentSize },
+          onScroll: (event) => {
+            if (pinchGestureRef.current)
+              return;
+            const { y } = event.nativeEvent.contentOffset;
+            const displacement = y - scrollPositionRef.current.y;
+            scrollPositionRef.current = { ...scrollPositionRef.current, y };
+            if (displacement !== 0)
+              pan({ x: 0, y: -displacement });
+          },
+          children: /* @__PURE__ */ jsx(import_react_native.View, {
+            style: {
+              height: scrollMapping.vertical.contentSize,
+              width: scrollMapping.horizontal.contentSize
+            },
+            children: visibleItems.map((item) => {
+              const position = worldToViewport({ x: item.x, y: item.y }, { ...viewport, offsetX: 0, offsetY: 0 });
+              return /* @__PURE__ */ jsx(import_react_native.View, {
+                style: {
+                  height: item.height * viewport.pixelsPerUnitY,
+                  left: position.x + scrollMapping.horizontal.origin,
+                  position: "absolute",
+                  top: position.y + scrollMapping.vertical.origin,
+                  width: item.width * viewport.pixelsPerUnitX
+                },
+                children: renderItem(item)
+              }, item.id);
+            })
+          })
+        })
+      }),
+      interactive ? /* @__PURE__ */ jsxs(import_react_native.View, {
+        accessibilityLabel: "Viewport controls",
+        style: controlsStyle,
+        children: [
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan left",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: 48, y: 0 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "←"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan right",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: -48, y: 0 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "→"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan up",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: 0, y: 48 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "↑"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan down",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: 0, y: -48 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "↓"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Zoom in",
+            accessibilityRole: "button",
+            onPress: () => zoomAt({ x: width / 2, y: height / 2 }, 1.2),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "+"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Zoom out",
+            accessibilityRole: "button",
+            onPress: () => zoomAt({ x: width / 2, y: height / 2 }, 1 / 1.2),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "−"
+            })
+          })
+        ]
+      }) : null
+    ]
+  });
+}
+var controlsStyle = { bottom: 8, gap: 4, position: "absolute", right: 8 };
+function createInitialViewport(width, height, zoom, viewport) {
+  return {
+    height,
+    offsetX: viewport?.offsetX ?? 0,
+    offsetY: viewport?.offsetY ?? 0,
+    pixelsPerUnitX: viewport?.pixelsPerUnitX ?? zoom,
+    pixelsPerUnitY: viewport?.pixelsPerUnitY ?? zoom,
+    width
+  };
+}
+function createContentConstraints(contentWidth, contentHeight) {
+  return { world: { height: contentHeight, width: contentWidth, x: 0, y: 0 } };
+}
+function createScrollMapping(viewport, constraints) {
+  const horizontalMinimum = constrainViewport({ ...viewport, offsetX: -Number.MAX_SAFE_INTEGER }, constraints).offsetX;
+  const horizontalMaximum = constrainViewport({ ...viewport, offsetX: Number.MAX_SAFE_INTEGER }, constraints).offsetX;
+  const verticalMinimum = constrainViewport({ ...viewport, offsetY: -Number.MAX_SAFE_INTEGER }, constraints).offsetY;
+  const verticalMaximum = constrainViewport({ ...viewport, offsetY: Number.MAX_SAFE_INTEGER }, constraints).offsetY;
+  return {
+    horizontal: createScrollAxisMapping({
+      maximum: horizontalMaximum,
+      minimum: horizontalMinimum,
+      offset: viewport.offsetX,
+      scale: viewport.pixelsPerUnitX,
+      viewportSize: viewport.width
+    }),
+    vertical: createScrollAxisMapping({
+      maximum: verticalMaximum,
+      minimum: verticalMinimum,
+      offset: viewport.offsetY,
+      scale: viewport.pixelsPerUnitY,
+      viewportSize: viewport.height
+    })
+  };
+}
+function createScrollAxisMapping({
+  maximum,
+  minimum,
+  offset,
+  scale,
+  viewportSize
+}) {
+  const range = (maximum - minimum) * scale;
+  return {
+    contentSize: viewportSize + range,
+    origin: -minimum * scale,
+    position: (offset - minimum) * scale
+  };
+}
+function areViewportsEqual(left, right) {
+  return left.width === right.width && left.height === right.height && left.offsetX === right.offsetX && left.offsetY === right.offsetY && left.pixelsPerUnitX === right.pixelsPerUnitX && left.pixelsPerUnitY === right.pixelsPerUnitY;
+}
+function areScrollPositionsEqual(left, right) {
+  return left.x === right.x && left.y === right.y;
+}
+function isRepeatedControlledFocusRevealProposal({
+  controlled,
+  focusedItemId,
+  previous,
+  sourceViewport,
+  viewport
+}) {
+  return controlled && focusedItemId !== undefined && previous?.focusedItemId === focusedItemId && areViewportsEqual(previous.sourceViewport, sourceViewport) && areViewportsEqual(previous.viewport, viewport);
+}
+function getPinchGesture(touches, width, height, viewportOrigin) {
+  const [first, second] = touches;
+  if (!first || !second)
+    return;
+  const deltaX = second.pageX - first.pageX;
+  const deltaY = second.pageY - first.pageY;
+  const distance = Math.hypot(deltaX, deltaY);
+  if (!Number.isFinite(distance) || distance === 0)
+    return;
+  return {
+    distance,
+    focalPoint: {
+      x: Math.min(width, Math.max(0, (first.pageX + second.pageX) / 2 - viewportOrigin.x)),
+      y: Math.min(height, Math.max(0, (first.pageY + second.pageY) / 2 - viewportOrigin.y))
+    }
+  };
+}
+
+// src/features/grid-view/adapters/inbound/TileGrid.tsx
+var import_react_native2 = __toESM(require_cjs(), 1);
+import React2 from "react";
+
+// src/features/grid-view/application/layoutTileGrid.ts
+function layoutTileGrid(items, viewportWidth, tileSize, gap, zoom = 1) {
+  if (![viewportWidth, tileSize, gap, zoom].every(Number.isFinite) || viewportWidth < 0 || tileSize <= 0 || gap < 0 || zoom <= 0) {
+    throw new RangeError("Tile layout requires finite, nonnegative dimensions and positive scales.");
+  }
+  const columns = Math.max(1, Math.floor((viewportWidth / zoom + gap) / (tileSize + gap)));
+  const rows = Math.ceil(items.length / columns);
+  return {
+    columns,
+    width: columns * (tileSize + gap) - gap,
+    height: Math.max(0, rows * (tileSize + gap) - gap),
+    items: items.map((item, index) => ({
+      id: item.id,
+      x: index % columns * (tileSize + gap),
+      y: Math.floor(index / columns) * (tileSize + gap),
+      width: tileSize,
+      height: tileSize
+    }))
+  };
+}
+
+// src/features/grid-view/adapters/inbound/TileGrid.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function TileGrid2({
+  items,
+  width,
+  height = 440,
+  tileSize = 120,
+  gap = 12,
+  zoom = 1,
+  viewport,
+  defaultViewport,
+  viewportConstraints,
+  zoomLimits,
+  overscanPixels,
+  focusedItemId,
+  revealPaddingPixels,
+  onColumnsChange,
+  onViewportChange,
+  onVisibleItemIdsChange,
+  renderItem,
+  interactionPolicy,
+  testID
+}) {
+  const [measuredWidth, setMeasuredWidth] = React2.useState(0);
+  const [uncontrolledPixelsPerUnitX, setUncontrolledPixelsPerUnitX] = React2.useState(() => defaultViewport?.pixelsPerUnitX ?? zoom);
+  const resolvedWidth = width ?? measuredWidth;
+  const pixelsPerUnitX = viewport?.pixelsPerUnitX ?? uncontrolledPixelsPerUnitX;
+  const layout = React2.useMemo(() => layoutTileGrid(items, resolvedWidth, tileSize, gap, pixelsPerUnitX), [gap, items, pixelsPerUnitX, resolvedWidth, tileSize]);
+  const itemLookup = React2.useMemo(() => new Map(items.map((item) => [item.id, item])), [items]);
+  React2.useEffect(() => {
+    if (resolvedWidth > 0)
+      onColumnsChange?.(layout.columns);
+  }, [layout.columns, onColumnsChange, resolvedWidth]);
+  const handleViewportChange = React2.useCallback((nextViewport) => {
+    if (viewport === undefined)
+      setUncontrolledPixelsPerUnitX(nextViewport.pixelsPerUnitX);
+    onViewportChange?.(nextViewport);
+  }, [onViewportChange, viewport]);
+  return /* @__PURE__ */ jsx2(import_react_native2.View, {
+    onLayout: (event) => setMeasuredWidth(event.nativeEvent.layout.width),
+    style: { width, height, overflow: "hidden" },
+    testID,
+    children: resolvedWidth > 0 ? /* @__PURE__ */ jsx2(GridView2, {
+      contentHeight: layout.height,
+      contentWidth: Math.max(resolvedWidth / pixelsPerUnitX, layout.width),
+      defaultViewport,
+      height,
+      focusedItemId,
+      interactionPolicy,
+      items: layout.items,
+      onVisibleItemIdsChange,
+      onViewportChange: handleViewportChange,
+      overscanPixels,
+      renderItem: (item) => {
+        const source = itemLookup.get(item.id);
+        return source ? renderItem(source) : null;
+      },
+      revealPaddingPixels,
+      width: resolvedWidth,
+      viewport,
+      viewportConstraints,
+      zoomLimits,
+      zoom
+    }) : null
+  });
+}
+export { GridView2, TileGrid2 };

package/web-dist/chunks/{Accordion-0my2z6qe.js → Accordion-bz04casa.js}

@@ -109,6 +109,89 @@ function getLaneIntervalPlacement(lanes, interval) {
   return resolveLaneIntervalPlacement(interval, laneMetrics);
 }
 
+// node_modules/@ankhorage/grid-view/dist/features/layout/utils/resolveMatrixCellPlacement.js
+function resolveMatrixCellPlacement(cell, rows, columns) {
+  if (!cell.id) {
+    throw new RangeError("Matrix cells require a nonempty ID.");
+  }
+  const rowIndex = rows.indexes.get(cell.rowId);
+  const columnIndex = columns.indexes.get(cell.columnId);
+  if (rowIndex === undefined || columnIndex === undefined) {
+    throw new RangeError("Matrix cells must reference an existing row and column.");
+  }
+  return {
+    ...cell,
+    rowIndex,
+    columnIndex,
+    x: readGridAxisMetric(columns.offsets, columnIndex),
+    y: readGridAxisMetric(rows.offsets, rowIndex),
+    width: readGridAxisMetric(columns.sizes, columnIndex),
+    height: readGridAxisMetric(rows.sizes, rowIndex)
+  };
+}
+
+// node_modules/@ankhorage/grid-view/dist/features/layout/getVisibleMatrixCells.js
+function getVisibleMatrixCells(layout, cells, viewport, overscanPixels = 0) {
+  const rows = createGridAxisMetrics(layout.rows);
+  const columns = createGridAxisMetrics(layout.columns);
+  validateUniqueIds(cells, "Matrix cells");
+  const bounds = getVisibleWorldBounds(viewport, overscanPixels);
+  const rowRange = getIntersectingRange(rows.offsets, rows.sizes, bounds.y, bounds.height);
+  const columnRange = getIntersectingRange(columns.offsets, columns.sizes, bounds.x, bounds.width);
+  if (rowRange === undefined || columnRange === undefined) {
+    return [];
+  }
+  return cells.flatMap((cell) => {
+    const placement = resolveMatrixCellPlacement(cell, rows, columns);
+    return placement.rowIndex >= rowRange.start && placement.rowIndex <= rowRange.end && placement.columnIndex >= columnRange.start && placement.columnIndex <= columnRange.end ? [placement] : [];
+  });
+}
+function validateUniqueIds(cells, label) {
+  const ids = new Set;
+  cells.forEach(({ id }) => {
+    if (ids.has(id)) {
+      throw new RangeError(`${label} require unique IDs.`);
+    }
+    ids.add(id);
+  });
+}
+function getIntersectingRange(offsets, sizes, start, extent) {
+  const end = start + extent;
+  const first = findFirstEndingAtOrAfter(offsets, sizes, start);
+  const last = findLastStartingAtOrBefore(offsets, end);
+  return first === undefined || last === undefined || first > last ? undefined : { start: first, end: last };
+}
+function findFirstEndingAtOrAfter(offsets, sizes, coordinate) {
+  let low = 0;
+  let high = offsets.length - 1;
+  let result;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    if (readGridAxisMetric(offsets, middle) + readGridAxisMetric(sizes, middle) >= coordinate) {
+      result = middle;
+      high = middle - 1;
+    } else {
+      low = middle + 1;
+    }
+  }
+  return result;
+}
+function findLastStartingAtOrBefore(offsets, coordinate) {
+  let low = 0;
+  let high = offsets.length - 1;
+  let result;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    if (readGridAxisMetric(offsets, middle) <= coordinate) {
+      result = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return result;
+}
+
 // node_modules/@ankhorage/grid-view/dist/features/viewport/constrainViewport.js
 function constrainViewport(viewport, constraints) {
   assertValidViewport(viewport);
@@ -143,6 +226,18 @@ function isAlignment(value) {
   return value === "start" || value === "center" || value === "end";
 }
 
+// node_modules/@ankhorage/grid-view/dist/features/viewport/panViewport.js
+function panViewport(viewport, displacement, constraints) {
+  if (![displacement.x, displacement.y].every(Number.isFinite)) {
+    throw new RangeError("Pan displacement must be finite.");
+  }
+  return constrainViewport({
+    ...viewport,
+    offsetX: viewport.offsetX - displacement.x / viewport.pixelsPerUnitX,
+    offsetY: viewport.offsetY - displacement.y / viewport.pixelsPerUnitY
+  }, constraints);
+}
+
 // node_modules/@ankhorage/grid-view/dist/features/viewport/revealWorldRect.js
 function revealWorldRect(viewport, rect, paddingPixels = 0, constraints) {
   validateRevealInput(viewport, rect, paddingPixels);
@@ -192,6 +287,34 @@ function worldToViewport(point, viewport) {
   };
 }
 
+// node_modules/@ankhorage/grid-view/dist/features/viewport/zoomViewportAt.js
+function zoomViewportAt(viewport, focalPoint, nextScale, limits = {}, constraints) {
+  if (![focalPoint.x, focalPoint.y, nextScale.pixelsPerUnitX, nextScale.pixelsPerUnitY].every(Number.isFinite)) {
+    throw new RangeError("Focal points and scales must be finite.");
+  }
+  const focalWorld = viewportToWorld(focalPoint, viewport);
+  const x = constrainScale(nextScale.pixelsPerUnitX, limits.minX, limits.maxX);
+  const y = constrainScale(nextScale.pixelsPerUnitY, limits.minY, limits.maxY);
+  return constrainViewport({
+    ...viewport,
+    pixelsPerUnitX: x,
+    pixelsPerUnitY: y,
+    offsetX: focalWorld.x - focalPoint.x / x,
+    offsetY: focalWorld.y - focalPoint.y / y
+  }, constraints);
+}
+function constrainScale(scale, minimum, maximum) {
+  const min = minimum ?? Number.EPSILON;
+  const max = maximum ?? Infinity;
+  if (!Number.isFinite(min) || min <= 0 || maximum !== undefined && (!Number.isFinite(max) || max <= 0 || min > max)) {
+    throw new RangeError("Zoom limits must be finite positive ranges.");
+  }
+  if (scale <= 0) {
+    throw new RangeError("Viewport scales must be positive.");
+  }
+  return Math.max(min, Math.min(max, scale));
+}
+
 // node_modules/@ankhorage/grid-view/dist/features/axes/getAxisCategoryTicks.js
 function getAxisCategoryTicks(viewport, axis, categories) {
   const bounds = getVisibleWorldBounds(viewport);
@@ -268,17 +391,23 @@ function adaptiveStep(minimum) {
   const multiplier = [1, 2, 5, 10].find((candidate) => candidate * magnitude >= minimum) ?? 10;
   return multiplier * magnitude;
 }
+// node_modules/@ankhorage/grid-view/dist/features/layout/getMatrixCellPlacement.js
+function getMatrixCellPlacement(layout, cell) {
+  const rows = createGridAxisMetrics(layout.rows);
+  const columns = createGridAxisMetrics(layout.columns);
+  return resolveMatrixCellPlacement(cell, rows, columns);
+}
 // node_modules/@ankhorage/grid-view/dist/features/layout/getVisibleLaneIntervals.js
 function getVisibleLaneIntervals(lanes, intervals, viewport, overscanPixels = 0) {
   const laneMetrics = createGridAxisMetrics(lanes.map(({ id, height }) => ({ id, size: height })));
   const bounds = getVisibleWorldBounds(viewport, overscanPixels);
-  validateUniqueIds(intervals);
+  validateUniqueIds2(intervals);
   return intervals.flatMap((interval) => {
     const placement = resolveLaneIntervalPlacement(interval, laneMetrics);
     return intersects(placement.x, placement.width, bounds.x, bounds.width) && intersects(placement.y, placement.height, bounds.y, bounds.height) ? [placement] : [];
   });
 }
-function validateUniqueIds(intervals) {
+function validateUniqueIds2(intervals) {
   const ids = new Set;
   intervals.forEach(({ id }) => {
     if (ids.has(id)) {
@@ -290,4 +419,4 @@ function validateUniqueIds(intervals) {
 function intersects(firstStart, firstExtent, secondStart, secondExtent) {
   return firstStart <= secondStart + secondExtent && firstStart + firstExtent >= secondStart;
 }
-export { getAxisCategoryTicks, getAxisTicks, getVisibleGridItems, getLaneIntervalPlacement, getVisibleLaneIntervals, revealWorldRect, worldToViewport };
+export { getAxisCategoryTicks, getAxisTicks, getVisibleGridItems, getLaneIntervalPlacement, getMatrixCellPlacement, getVisibleLaneIntervals, getVisibleMatrixCells, constrainViewport, panViewport, revealWorldRect, worldToViewport, zoomViewportAt };

package/web-dist/chunks/{Accordion-7qfd4cb4.js → Accordion-jh72azm2.js}

@@ -6,7 +6,7 @@ import {
   getAxisCategoryTicks,
   getAxisTicks,
   worldToViewport
-} from "./Accordion-0my2z6qe.js";
+} from "./Accordion-bz04casa.js";
 import {
   useZoraTheme2
 } from "./Accordion-srjya6dz.js";