@szum-tech/design-system 3.16.0 → 3.18.1

package/dist/chunk-WCQ5WKCQ.js

@@ -1,1042 +0,0 @@
-import { useComposedRefs } from './chunk-P4IL77YC.js';
-import { useIsomorphicLayoutEffect } from './chunk-G24PWQKG.js';
-import * as React3 from 'react';
-import React3__default from 'react';
-import { Slot } from '@radix-ui/react-slot';
-import { jsx } from 'react/jsx-runtime';
-
-function MasonryItem({ asChild, ref, ...props }) {
-  const ItemPrimitive = asChild ? Slot : "div";
-  return /* @__PURE__ */ jsx(ItemPrimitive, { "data-slot": "masonry-item", ref, ...props });
-}
-
-// src/components/masonry/masonry.constants.ts
-var COLUMN_WIDTH = 200;
-var GAP = 0;
-var ITEM_HEIGHT = 300;
-var OVERSCAN = 2;
-var SCROLL_FPS = 12;
-var DEBOUNCE_DELAY = 300;
-var ROOT_NAME = "MasonryRoot";
-var VIEWPORT_NAME = "MasonryViewport";
-var ITEM_NAME = "MasonryItem";
-var MASONRY_ERROR = {
-  [ROOT_NAME]: `\`${ROOT_NAME}\` components must be within \`${ROOT_NAME}\``,
-  [VIEWPORT_NAME]: `\`${VIEWPORT_NAME}\` components must be within \`${ROOT_NAME}\``,
-  [ITEM_NAME]: `\`${ITEM_NAME}\` must be within \`${VIEWPORT_NAME}\``
-};
-var NODE_COLOR = {
-  RED: 0,
-  BLACK: 1,
-  SENTINEL: 2
-};
-var NODE_OPERATION = {
-  REMOVE: 0,
-  PRESERVE: 1
-};
-var MasonryContext = React3__default.createContext(null);
-function useMasonryContext(name) {
-  const context = React3__default.useContext(MasonryContext);
-  if (!context) {
-    throw new Error(MASONRY_ERROR[name]);
-  }
-  return context;
-}
-function MasonryViewport({ children, style, ref, ...props }) {
-  const context = useMasonryContext(VIEWPORT_NAME);
-  const [layoutVersion, setLayoutVersion] = React3.useState(0);
-  const rafId = React3.useRef(null);
-  const [mounted, setMounted] = React3.useState(false);
-  useIsomorphicLayoutEffect(() => {
-    setMounted(true);
-  }, []);
-  const validChildren = React3.Children.toArray(children).filter(
-    (child) => React3.isValidElement(child) && (child.type === MasonryItem || child.type === MasonryItem)
-  );
-  const itemCount = validChildren.length;
-  const shortestColumnSize = context.positioner.shortestColumn();
-  const measuredCount = context.positioner.size();
-  const overscanPixels = context.windowHeight * context.overscan;
-  const rangeStart = Math.max(0, context.scrollTop - overscanPixels / 2);
-  const rangeEnd = context.scrollTop + overscanPixels;
-  const layoutOutdated = shortestColumnSize < rangeEnd && measuredCount < itemCount;
-  const positionedChildren = [];
-  const visibleItemStyle = React3.useMemo(
-    () => ({
-      position: "absolute",
-      writingMode: "horizontal-tb",
-      visibility: "visible",
-      width: context.columnWidth,
-      transform: context.isScrolling ? "translateZ(0)" : void 0,
-      willChange: context.isScrolling ? "transform" : void 0
-    }),
-    [context.columnWidth, context.isScrolling]
-  );
-  const hiddenItemStyle = React3.useMemo(
-    () => ({
-      position: "absolute",
-      writingMode: "horizontal-tb",
-      visibility: "hidden",
-      width: context.columnWidth,
-      zIndex: -1e3
-    }),
-    [context.columnWidth]
-  );
-  context.positioner.range(rangeStart, rangeEnd, (index, left, top) => {
-    const child = validChildren[index];
-    if (!child) return;
-    const itemStyle = {
-      ...visibleItemStyle,
-      top,
-      left,
-      ...child.props.style
-    };
-    positionedChildren.push(
-      React3.cloneElement(child, {
-        key: child.key ?? index,
-        ref: context.onItemRegister(index),
-        style: itemStyle
-      })
-    );
-  });
-  if (layoutOutdated && mounted) {
-    const batchSize = Math.min(
-      itemCount - measuredCount,
-      Math.ceil(
-        (context.scrollTop + overscanPixels - shortestColumnSize) / context.itemHeight * context.positioner.columnCount
-      )
-    );
-    for (let index = measuredCount; index < measuredCount + batchSize; index++) {
-      const child = validChildren[index];
-      if (!child) continue;
-      const itemStyle = {
-        ...hiddenItemStyle,
-        ...child.props.style
-      };
-      positionedChildren.push(
-        React3.cloneElement(child, {
-          key: child.key ?? index,
-          ref: context.onItemRegister(index),
-          style: itemStyle
-        })
-      );
-    }
-  }
-  React3.useEffect(() => {
-    if (layoutOutdated && mounted) {
-      if (rafId.current) {
-        cancelAnimationFrame(rafId.current);
-      }
-      rafId.current = requestAnimationFrame(() => {
-        setLayoutVersion((v) => v + 1);
-      });
-    }
-    return () => {
-      if (rafId.current) {
-        cancelAnimationFrame(rafId.current);
-      }
-    };
-  }, [layoutOutdated, mounted]);
-  const estimatedHeight = React3.useMemo(() => {
-    const measuredHeight = context.positioner.estimateHeight(measuredCount, context.itemHeight);
-    if (measuredCount === itemCount) {
-      return measuredHeight;
-    }
-    const remainingItems = itemCount - measuredCount;
-    const estimatedRemainingHeight = Math.ceil(remainingItems / context.positioner.columnCount * context.itemHeight);
-    return measuredHeight + estimatedRemainingHeight;
-  }, [context.positioner, context.itemHeight, measuredCount, itemCount]);
-  const containerStyle = React3.useMemo(
-    () => ({
-      position: "relative",
-      width: "100%",
-      maxWidth: "100%",
-      height: Math.ceil(estimatedHeight),
-      maxHeight: Math.ceil(estimatedHeight),
-      willChange: context.isScrolling ? "contents" : void 0,
-      pointerEvents: context.isScrolling ? "none" : void 0,
-      ...style
-    }),
-    [context.isScrolling, estimatedHeight, style]
-  );
-  if (!mounted && context.fallback) {
-    return context.fallback;
-  }
-  return /* @__PURE__ */ jsx("div", { ref, style: containerStyle, "data-version": mounted ? layoutVersion : void 0, ...props, children: positionedChildren });
-}
-
-// src/components/masonry/masonry.utils.ts
-function addInterval(treeNode, high, index) {
-  let node = treeNode.list;
-  let prevNode;
-  while (node) {
-    if (node.index === index) return false;
-    if (high > node.high) break;
-    prevNode = node;
-    node = node.next;
-  }
-  if (!prevNode) treeNode.list = { index, high, next: node };
-  if (prevNode) prevNode.next = { index, high, next: prevNode.next };
-  return true;
-}
-function removeInterval(treeNode, index) {
-  let node = treeNode.list;
-  if (node.index === index) {
-    if (node.next === null) return NODE_OPERATION.REMOVE;
-    treeNode.list = node.next;
-    return NODE_OPERATION.PRESERVE;
-  }
-  let prevNode = node;
-  node = node.next;
-  while (node !== null) {
-    if (node.index === index) {
-      prevNode.next = node.next;
-      return NODE_OPERATION.PRESERVE;
-    }
-    prevNode = node;
-    node = node.next;
-  }
-}
-var SENTINEL_NODE = {
-  low: 0,
-  max: 0,
-  high: 0,
-  color: NODE_COLOR.SENTINEL,
-  parent: void 0,
-  right: void 0,
-  left: void 0,
-  list: void 0
-};
-SENTINEL_NODE.parent = SENTINEL_NODE;
-SENTINEL_NODE.left = SENTINEL_NODE;
-SENTINEL_NODE.right = SENTINEL_NODE;
-function updateMax(node) {
-  const max = node.high;
-  if (node.left === SENTINEL_NODE && node.right === SENTINEL_NODE) node.max = max;
-  else if (node.left === SENTINEL_NODE) node.max = Math.max(node.right.max, max);
-  else if (node.right === SENTINEL_NODE) node.max = Math.max(node.left.max, max);
-  else node.max = Math.max(Math.max(node.left.max, node.right.max), max);
-}
-function updateMaxUp(node) {
-  let x = node;
-  while (x.parent !== SENTINEL_NODE) {
-    updateMax(x.parent);
-    x = x.parent;
-  }
-}
-function rotateLeft(tree, x) {
-  if (x.right === SENTINEL_NODE) return;
-  const y = x.right;
-  x.right = y.left;
-  if (y.left !== SENTINEL_NODE) y.left.parent = x;
-  y.parent = x.parent;
-  if (x.parent === SENTINEL_NODE) tree.root = y;
-  else if (x === x.parent.left) x.parent.left = y;
-  else x.parent.right = y;
-  y.left = x;
-  x.parent = y;
-  updateMax(x);
-  updateMax(y);
-}
-function rotateRight(tree, x) {
-  if (x.left === SENTINEL_NODE) return;
-  const y = x.left;
-  x.left = y.right;
-  if (y.right !== SENTINEL_NODE) y.right.parent = x;
-  y.parent = x.parent;
-  if (x.parent === SENTINEL_NODE) tree.root = y;
-  else if (x === x.parent.right) x.parent.right = y;
-  else x.parent.left = y;
-  y.right = x;
-  x.parent = y;
-  updateMax(x);
-  updateMax(y);
-}
-function replaceNode(tree, x, y) {
-  if (x.parent === SENTINEL_NODE) {
-    tree.root = y;
-  } else if (x === x.parent.left) {
-    x.parent.left = y;
-  } else {
-    x.parent.right = y;
-  }
-  y.parent = x.parent;
-}
-function fixRemove(tree, node) {
-  let x = node;
-  let w;
-  while (x !== SENTINEL_NODE && x.color === NODE_COLOR.BLACK) {
-    if (x === x.parent.left) {
-      w = x.parent.right;
-      if (w.color === NODE_COLOR.RED) {
-        w.color = NODE_COLOR.BLACK;
-        x.parent.color = NODE_COLOR.RED;
-        rotateLeft(tree, x.parent);
-        w = x.parent.right;
-      }
-      if (w.left.color === NODE_COLOR.BLACK && w.right.color === NODE_COLOR.BLACK) {
-        w.color = NODE_COLOR.RED;
-        x = x.parent;
-      } else {
-        if (w.right.color === NODE_COLOR.BLACK) {
-          w.left.color = NODE_COLOR.BLACK;
-          w.color = NODE_COLOR.RED;
-          rotateRight(tree, w);
-          w = x.parent.right;
-        }
-        w.color = x.parent.color;
-        x.parent.color = NODE_COLOR.BLACK;
-        w.right.color = NODE_COLOR.BLACK;
-        rotateLeft(tree, x.parent);
-        x = tree.root;
-      }
-    } else {
-      w = x.parent.left;
-      if (w.color === NODE_COLOR.RED) {
-        w.color = NODE_COLOR.BLACK;
-        x.parent.color = NODE_COLOR.RED;
-        rotateRight(tree, x.parent);
-        w = x.parent.left;
-      }
-      if (w.right.color === NODE_COLOR.BLACK && w.left.color === NODE_COLOR.BLACK) {
-        w.color = NODE_COLOR.RED;
-        x = x.parent;
-      } else {
-        if (w.left.color === NODE_COLOR.BLACK) {
-          w.right.color = NODE_COLOR.BLACK;
-          w.color = NODE_COLOR.RED;
-          rotateLeft(tree, w);
-          w = x.parent.left;
-        }
-        w.color = x.parent.color;
-        x.parent.color = NODE_COLOR.BLACK;
-        w.left.color = NODE_COLOR.BLACK;
-        rotateRight(tree, x.parent);
-        x = tree.root;
-      }
-    }
-  }
-  x.color = NODE_COLOR.BLACK;
-}
-function minimumTree(node) {
-  let current = node;
-  while (current.left !== SENTINEL_NODE) {
-    current = current.left;
-  }
-  return current;
-}
-function fixInsert(tree, node) {
-  let current = node;
-  let y;
-  while (current.parent.color === NODE_COLOR.RED) {
-    if (current.parent === current.parent.parent.left) {
-      y = current.parent.parent.right;
-      if (y.color === NODE_COLOR.RED) {
-        current.parent.color = NODE_COLOR.BLACK;
-        y.color = NODE_COLOR.BLACK;
-        current.parent.parent.color = NODE_COLOR.RED;
-        current = current.parent.parent;
-      } else {
-        if (current === current.parent.right) {
-          current = current.parent;
-          rotateLeft(tree, current);
-        }
-        current.parent.color = NODE_COLOR.BLACK;
-        current.parent.parent.color = NODE_COLOR.RED;
-        rotateRight(tree, current.parent.parent);
-      }
-    } else {
-      y = current.parent.parent.left;
-      if (y.color === NODE_COLOR.RED) {
-        current.parent.color = NODE_COLOR.BLACK;
-        y.color = NODE_COLOR.BLACK;
-        current.parent.parent.color = NODE_COLOR.RED;
-        current = current.parent.parent;
-      } else {
-        if (current === current.parent.left) {
-          current = current.parent;
-          rotateRight(tree, current);
-        }
-        current.parent.color = NODE_COLOR.BLACK;
-        current.parent.parent.color = NODE_COLOR.RED;
-        rotateLeft(tree, current.parent.parent);
-      }
-    }
-  }
-  tree.root.color = NODE_COLOR.BLACK;
-}
-function createIntervalTree() {
-  const tree = {
-    root: SENTINEL_NODE,
-    size: 0
-  };
-  const indexMap = {};
-  return {
-    insert(low, high, index) {
-      let x = tree.root;
-      let y = SENTINEL_NODE;
-      while (x !== SENTINEL_NODE) {
-        y = x;
-        if (low === y.low) break;
-        if (low < x.low) x = x.left;
-        else x = x.right;
-      }
-      if (low === y.low && y !== SENTINEL_NODE) {
-        if (!addInterval(y, high, index)) return;
-        y.high = Math.max(y.high, high);
-        updateMax(y);
-        updateMaxUp(y);
-        indexMap[index] = y;
-        tree.size++;
-        return;
-      }
-      const z = {
-        low,
-        high,
-        max: high,
-        color: NODE_COLOR.RED,
-        parent: y,
-        left: SENTINEL_NODE,
-        right: SENTINEL_NODE,
-        list: { index, high, next: null }
-      };
-      if (y === SENTINEL_NODE) {
-        tree.root = z;
-      } else {
-        if (z.low < y.low) y.left = z;
-        else y.right = z;
-        updateMaxUp(z);
-      }
-      fixInsert(tree, z);
-      indexMap[index] = z;
-      tree.size++;
-    },
-    remove(index) {
-      const z = indexMap[index];
-      if (z === void 0) return;
-      delete indexMap[index];
-      const intervalResult = removeInterval(z, index);
-      if (intervalResult === void 0) return;
-      if (intervalResult === NODE_OPERATION.PRESERVE) {
-        z.high = z.list.high;
-        updateMax(z);
-        updateMaxUp(z);
-        tree.size--;
-        return;
-      }
-      let y = z;
-      let originalYColor = y.color;
-      let x;
-      if (z.left === SENTINEL_NODE) {
-        x = z.right;
-        replaceNode(tree, z, z.right);
-      } else if (z.right === SENTINEL_NODE) {
-        x = z.left;
-        replaceNode(tree, z, z.left);
-      } else {
-        y = minimumTree(z.right);
-        originalYColor = y.color;
-        x = y.right;
-        if (y.parent === z) {
-          x.parent = y;
-        } else {
-          replaceNode(tree, y, y.right);
-          y.right = z.right;
-          y.right.parent = y;
-        }
-        replaceNode(tree, z, y);
-        y.left = z.left;
-        y.left.parent = y;
-        y.color = z.color;
-      }
-      updateMax(x);
-      updateMaxUp(x);
-      if (originalYColor === NODE_COLOR.BLACK) fixRemove(tree, x);
-      tree.size--;
-    },
-    search(low, high, onCallback) {
-      const stack = [tree.root];
-      while (stack.length !== 0) {
-        const node = stack.pop();
-        if (!node) continue;
-        if (node === SENTINEL_NODE || low > node.max) continue;
-        if (node.left !== SENTINEL_NODE) stack.push(node.left);
-        if (node.right !== SENTINEL_NODE) stack.push(node.right);
-        if (node.low <= high && node.high >= low) {
-          let curr = node.list;
-          while (curr !== null) {
-            if (curr.high >= low) onCallback(curr.index, node.low);
-            curr = curr.next;
-          }
-        }
-      }
-    },
-    get size() {
-      return tree.size;
-    }
-  };
-}
-function onDeepMemo(constructors, fn) {
-  if (!constructors.length || !constructors[0]) {
-    throw new Error("At least one constructor is required");
-  }
-  function createCache(obj) {
-    let cache;
-    if (typeof obj === "function") {
-      try {
-        cache = new obj();
-      } catch (_err) {
-        cache = /* @__PURE__ */ new Map();
-      }
-    } else {
-      cache = obj;
-    }
-    return {
-      set(k, v) {
-        cache.set(k, v);
-        return v;
-      },
-      get(k) {
-        return cache.get(k);
-      }
-    };
-  }
-  const depth = constructors.length;
-  const baseCache = createCache(constructors[0]);
-  let base;
-  let map;
-  let node;
-  let i;
-  const one = depth === 1;
-  function get(args) {
-    if (depth < 3) {
-      const key = args[0];
-      base = baseCache.get(key);
-      return one ? base : base?.get(args[1]);
-    }
-    node = baseCache;
-    for (i = 0; i < depth; i++) {
-      const next = node.get(args[i]);
-      if (!next) return void 0;
-      node = next;
-    }
-    return node;
-  }
-  function set(args, value) {
-    if (depth < 3) {
-      if (one) {
-        baseCache.set(args[0], value);
-      } else {
-        base = baseCache.get(args[0]);
-        if (!base) {
-          if (!constructors[1]) {
-            throw new Error("Second constructor is required for non-single depth cache");
-          }
-          map = createCache(constructors[1]);
-          map.set(args[1], value);
-          baseCache.set(args[0], map);
-        } else {
-          base.set(args[1], value);
-        }
-      }
-      return value;
-    }
-    node = baseCache;
-    for (i = 0; i < depth - 1; i++) {
-      map = node.get(args[i]);
-      if (!map) {
-        const nextConstructor = constructors[i + 1];
-        if (!nextConstructor) {
-          throw new Error(`Constructor at index ${i + 1} is required`);
-        }
-        map = createCache(nextConstructor);
-        node.set(args[i], map);
-        node = map;
-      } else {
-        node = map;
-      }
-    }
-    node.set(args[depth - 1], value);
-    return value;
-  }
-  return (...args) => {
-    const cached = get(args);
-    if (cached === void 0) {
-      return set(args, fn(...args));
-    }
-    return cached;
-  };
-}
-function onRafSchedule(callback) {
-  function onCallback(...args) {
-  }
-  onCallback.cancel = () => {
-    return;
-  };
-  return onCallback;
-}
-
-// src/components/masonry/masonry.hooks.tsx
-function useMasonryPositioner({
-  width,
-  columnWidth,
-  columnGap = 0,
-  rowGap,
-  columnCount,
-  maxColumnCount,
-  linear = false
-}, deps = []) {
-  const initPositioner = React3__default.useCallback(() => {
-    function binarySearch(a, y) {
-      let l = 0;
-      let h = a.length - 1;
-      while (l <= h) {
-        const m = l + h >>> 1;
-        const x = a[m];
-        if (x === y) return m;
-        if (x === void 0 || x <= y) l = m + 1;
-        else h = m - 1;
-      }
-      return -1;
-    }
-    const computedColumnCount = columnCount || Math.min(
-      Math.floor((width + columnGap) / ((columnWidth ?? 0) + columnGap)),
-      maxColumnCount || Number.POSITIVE_INFINITY
-    ) || 1;
-    const computedColumnWidth = Math.floor((width - columnGap * (computedColumnCount - 1)) / computedColumnCount);
-    const intervalTree = createIntervalTree();
-    const columnHeights = new Array(computedColumnCount).fill(0);
-    const items = [];
-    const columnItems = new Array(computedColumnCount).fill(0).map(() => []);
-    for (let i = 0; i < computedColumnCount; i++) {
-      columnHeights[i] = 0;
-      columnItems[i] = [];
-    }
-    return {
-      columnCount: computedColumnCount,
-      columnWidth: computedColumnWidth,
-      set: (index, height = 0) => {
-        let columnIndex = 0;
-        if (linear) {
-          const preferredColumn = index % computedColumnCount;
-          let shortestHeight = columnHeights[0] ?? 0;
-          let shortestIndex = 0;
-          for (let i = 0; i < columnHeights.length; i++) {
-            const currentHeight = columnHeights[i] ?? 0;
-            if (currentHeight < shortestHeight) {
-              shortestHeight = currentHeight;
-              shortestIndex = i;
-            }
-          }
-          const preferredHeight = (columnHeights[preferredColumn] ?? 0) + height;
-          const maxAllowedHeight = shortestHeight + height * 2.5;
-          columnIndex = preferredHeight <= maxAllowedHeight ? preferredColumn : shortestIndex;
-        } else {
-          for (let i = 1; i < columnHeights.length; i++) {
-            const currentHeight = columnHeights[i];
-            const shortestHeight = columnHeights[columnIndex];
-            if (currentHeight !== void 0 && shortestHeight !== void 0 && currentHeight < shortestHeight) {
-              columnIndex = i;
-            }
-          }
-        }
-        const columnHeight = columnHeights[columnIndex];
-        if (columnHeight === void 0) return;
-        const top = columnHeight;
-        columnHeights[columnIndex] = top + height + (rowGap ?? columnGap);
-        const columnItemsList = columnItems[columnIndex];
-        if (!columnItemsList) return;
-        columnItemsList.push(index);
-        items[index] = {
-          left: columnIndex * (computedColumnWidth + columnGap),
-          top,
-          height,
-          columnIndex
-        };
-        intervalTree.insert(top, top + height, index);
-      },
-      get: (index) => items[index],
-      update: (updates) => {
-        const columns = new Array(computedColumnCount);
-        let i = 0;
-        let j = 0;
-        for (; i < updates.length - 1; i++) {
-          const currentIndex = updates[i];
-          if (typeof currentIndex !== "number") continue;
-          const item = items[currentIndex];
-          if (!item) continue;
-          const nextHeight = updates[++i];
-          if (typeof nextHeight !== "number") continue;
-          item.height = nextHeight;
-          intervalTree.remove(currentIndex);
-          intervalTree.insert(item.top, item.top + item.height, currentIndex);
-          columns[item.columnIndex] = columns[item.columnIndex] === void 0 ? currentIndex : Math.min(currentIndex, columns[item.columnIndex] ?? currentIndex);
-        }
-        for (i = 0; i < columns.length; i++) {
-          const currentColumn = columns[i];
-          if (currentColumn === void 0) continue;
-          const itemsInColumn = columnItems[i];
-          if (!itemsInColumn) continue;
-          const startIndex = binarySearch(itemsInColumn, currentColumn);
-          if (startIndex === -1) continue;
-          const currentItemIndex = itemsInColumn[startIndex];
-          if (typeof currentItemIndex !== "number") continue;
-          const startItem = items[currentItemIndex];
-          if (!startItem) continue;
-          const currentHeight = columnHeights[i];
-          if (typeof currentHeight !== "number") continue;
-          columnHeights[i] = startItem.top + startItem.height + (rowGap ?? columnGap);
-          for (j = startIndex + 1; j < itemsInColumn.length; j++) {
-            const currentIndex = itemsInColumn[j];
-            if (typeof currentIndex !== "number") continue;
-            const item = items[currentIndex];
-            if (!item) continue;
-            const columnHeight = columnHeights[i];
-            if (typeof columnHeight !== "number") continue;
-            item.top = columnHeight;
-            columnHeights[i] = item.top + item.height + (rowGap ?? columnGap);
-            intervalTree.remove(currentIndex);
-            intervalTree.insert(item.top, item.top + item.height, currentIndex);
-          }
-        }
-      },
-      range: (low, high, onItemRender) => intervalTree.search(low, high, (index, top) => {
-        const item = items[index];
-        if (!item) return;
-        onItemRender(index, item.left, top);
-      }),
-      estimateHeight: (itemCount, defaultItemHeight) => {
-        const tallestColumn = Math.max(0, Math.max.apply(null, columnHeights));
-        return itemCount === intervalTree.size ? tallestColumn : tallestColumn + Math.ceil((itemCount - intervalTree.size) / computedColumnCount) * defaultItemHeight;
-      },
-      shortestColumn: () => {
-        if (columnHeights.length > 1) return Math.min.apply(null, columnHeights);
-        return columnHeights[0] ?? 0;
-      },
-      size() {
-        return intervalTree.size;
-      },
-      all() {
-        return items.filter(Boolean);
-      }
-    };
-  }, [width, columnWidth, columnGap, rowGap, columnCount, maxColumnCount, linear]);
-  const positionerRef = React3__default.useRef(null);
-  if (positionerRef.current === null) positionerRef.current = initPositioner();
-  const prevDepsRef = React3__default.useRef(deps);
-  const opts = [width, columnWidth, columnGap, rowGap, columnCount, maxColumnCount, linear];
-  const prevOptsRef = React3__default.useRef(opts);
-  const optsChanged = !opts.every((item, i) => prevOptsRef.current[i] === item);
-  if (optsChanged || !deps.every((item, i) => prevDepsRef.current[i] === item)) {
-    const prevPositioner = positionerRef.current;
-    const positioner = initPositioner();
-    prevDepsRef.current = deps;
-    prevOptsRef.current = opts;
-    if (optsChanged) {
-      const cacheSize = prevPositioner.size();
-      for (let index = 0; index < cacheSize; index++) {
-        const pos = prevPositioner.get(index);
-        positioner.set(index, pos !== void 0 ? pos.height : 0);
-      }
-    }
-    positionerRef.current = positioner;
-  }
-  return positionerRef.current;
-}
-function useDebouncedWindowSize(options) {
-  const { containerRef, defaultWidth = 0, defaultHeight = 0, delayMs = DEBOUNCE_DELAY } = options;
-  const getDocumentSize = React3__default.useCallback(() => {
-    if (typeof document === "undefined") {
-      return { width: defaultWidth, height: defaultHeight };
-    }
-    return {
-      width: document.documentElement.clientWidth,
-      height: document.documentElement.clientHeight
-    };
-  }, [defaultWidth, defaultHeight]);
-  const [size, setSize] = React3__default.useState(getDocumentSize());
-  const timeoutRef = React3__default.useRef(null);
-  const setDebouncedSize = React3__default.useCallback(
-    (value) => {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current);
-      }
-      timeoutRef.current = setTimeout(() => {
-        setSize(value);
-      }, delayMs);
-    },
-    [delayMs]
-  );
-  React3__default.useEffect(() => {
-    function onResize() {
-      if (containerRef.current) {
-        setDebouncedSize({
-          width: containerRef.current.offsetWidth,
-          height: document.documentElement.clientHeight
-        });
-      } else {
-        setDebouncedSize(getDocumentSize());
-      }
-    }
-    window?.addEventListener("resize", onResize, { passive: true });
-    window?.addEventListener("orientationchange", onResize);
-    window.visualViewport?.addEventListener("resize", onResize);
-    return () => {
-      window?.removeEventListener("resize", onResize);
-      window?.removeEventListener("orientationchange", onResize);
-      window.visualViewport?.removeEventListener("resize", onResize);
-      if (timeoutRef.current) clearTimeout(timeoutRef.current);
-    };
-  }, [setDebouncedSize, containerRef, getDocumentSize]);
-  return size;
-}
-function useResizeObserver(positioner) {
-  const [, setLayoutVersion] = React3__default.useState(0);
-  const createResizeObserver = React3__default.useMemo(() => {
-    if (typeof window === "undefined") {
-      return () => ({
-        disconnect: () => {
-        },
-        observe: () => {
-        },
-        unobserve: () => {
-        }
-      });
-    }
-    return onDeepMemo([WeakMap], (positioner2, onUpdate) => {
-      const itemMap = /* @__PURE__ */ new WeakMap();
-      onRafSchedule();
-      const scheduledItemMap = /* @__PURE__ */ new Map();
-      function onResizeObserver(entries) {
-        for (const entry of entries) {
-          if (!entry) continue;
-          const index = itemMap.get(entry.target);
-          if (index === void 0) continue;
-          let handler = scheduledItemMap.get(index);
-          if (!handler) {
-            handler = onRafSchedule();
-            scheduledItemMap.set(index, handler);
-          }
-          handler(entry.target);
-        }
-      }
-      const observer = new ResizeObserver(onResizeObserver);
-      const disconnect = observer.disconnect.bind(observer);
-      observer.disconnect = () => {
-        disconnect();
-        for (const [, scheduleItem] of scheduledItemMap) {
-          scheduleItem.cancel();
-        }
-      };
-      return observer;
-    });
-  }, []);
-  const resizeObserver = createResizeObserver(positioner, () => setLayoutVersion((prev) => prev + 1));
-  React3__default.useEffect(() => () => resizeObserver.disconnect(), [resizeObserver]);
-  return resizeObserver;
-}
-function useScroller({
-  offset = 0,
-  fps = SCROLL_FPS
-} = {}) {
-  const [scrollY, setScrollY] = useThrottle(
-    typeof globalThis.window === "undefined" ? 0 : globalThis.window.scrollY ?? document.documentElement.scrollTop ?? 0,
-    { fps, leading: true }
-  );
-  const onScroll = React3__default.useCallback(() => {
-    setScrollY(globalThis.window.scrollY ?? document.documentElement.scrollTop ?? 0);
-  }, [setScrollY]);
-  React3__default.useEffect(() => {
-    if (typeof globalThis.window === "undefined") return;
-    globalThis.window.addEventListener("scroll", onScroll, { passive: true });
-    return () => globalThis.window.removeEventListener("scroll", onScroll);
-  }, [onScroll]);
-  const [isScrolling, setIsScrolling] = React3__default.useState(false);
-  const hasMountedRef = React3__default.useRef(0);
-  React3__default.useEffect(() => {
-    if (hasMountedRef.current === 1) setIsScrolling(true);
-    let didUnsubscribe = false;
-    function requestTimeout(fn, delay) {
-      const start = performance.now();
-      const handle = {
-        id: requestAnimationFrame(function tick(timestamp) {
-          if (timestamp - start >= delay) {
-            fn();
-          } else {
-            handle.id = requestAnimationFrame(tick);
-          }
-        })
-      };
-      return handle;
-    }
-    const timeout = requestTimeout(
-      () => {
-        if (didUnsubscribe) return;
-        setIsScrolling(false);
-      },
-      40 + 1e3 / fps
-    );
-    hasMountedRef.current = 1;
-    return () => {
-      didUnsubscribe = true;
-      cancelAnimationFrame(timeout.id);
-    };
-  }, [fps]);
-  return { scrollTop: Math.max(0, scrollY - offset), isScrolling };
-}
-function useThrottle(initialState, options = {}) {
-  const { fps = 30, leading = false } = options;
-  const [state, setState] = React3__default.useState(initialState);
-  const latestSetState = React3__default.useRef(setState);
-  latestSetState.current = setState;
-  const ms = 1e3 / fps;
-  const prevCountRef = React3__default.useRef(0);
-  const trailingTimeout = React3__default.useRef(null);
-  const clearTrailing = React3__default.useCallback(() => {
-    if (trailingTimeout.current) {
-      clearTimeout(trailingTimeout.current);
-    }
-  }, []);
-  React3__default.useEffect(() => {
-    return () => {
-      prevCountRef.current = 0;
-      clearTrailing();
-    };
-  }, [clearTrailing]);
-  const throttledSetState = React3__default.useCallback(
-    (action) => {
-      const perf = typeof performance !== "undefined" ? performance : Date;
-      const now = () => perf.now();
-      const rightNow = now();
-      const call = () => {
-        prevCountRef.current = rightNow;
-        clearTrailing();
-        latestSetState.current(action);
-      };
-      const current = prevCountRef.current;
-      if (leading && current === 0) {
-        return call();
-      }
-      if (rightNow - current > ms) {
-        if (current > 0) {
-          return call();
-        }
-        prevCountRef.current = rightNow;
-      }
-      clearTrailing();
-      trailingTimeout.current = setTimeout(() => {
-        call();
-        prevCountRef.current = 0;
-      }, ms);
-    },
-    [leading, ms, clearTrailing]
-  );
-  return [state, throttledSetState];
-}
-function Masonry(props) {
-  const {
-    columnWidth = COLUMN_WIDTH,
-    columnCount,
-    maxColumnCount,
-    gap = GAP,
-    itemHeight = ITEM_HEIGHT,
-    defaultWidth,
-    defaultHeight,
-    overscan = OVERSCAN,
-    scrollFps = SCROLL_FPS,
-    fallback,
-    linear = false,
-    asChild,
-    children,
-    style,
-    ref,
-    ...rootProps
-  } = props;
-  const gapValue = typeof gap === "object" ? gap : { column: gap, row: gap };
-  const columnGap = gapValue.column;
-  const rowGap = gapValue.row;
-  const containerRef = React3.useRef(null);
-  const composedRef = useComposedRefs(ref, containerRef);
-  const size = useDebouncedWindowSize({
-    containerRef,
-    defaultWidth,
-    defaultHeight
-  });
-  const [containerPosition, setContainerPosition] = React3.useState({ offset: 0, width: 0 });
-  useIsomorphicLayoutEffect(() => {
-    if (!containerRef.current) return;
-    let offset = 0;
-    let container = containerRef.current;
-    do {
-      offset += container.offsetTop ?? 0;
-      container = container.offsetParent;
-    } while (container);
-    if (offset !== containerPosition.offset || containerRef.current.offsetWidth !== containerPosition.width) {
-      setContainerPosition({
-        offset,
-        width: containerRef.current.offsetWidth
-      });
-    }
-  }, [containerPosition, size]);
-  const positioner = useMasonryPositioner({
-    width: containerPosition.width ?? size.width,
-    columnWidth,
-    columnGap,
-    rowGap,
-    columnCount,
-    maxColumnCount,
-    linear
-  });
-  const resizeObserver = useResizeObserver(positioner);
-  const { scrollTop, isScrolling } = useScroller({
-    offset: containerPosition.offset,
-    fps: scrollFps
-  });
-  const itemMap = React3.useRef(/* @__PURE__ */ new WeakMap()).current;
-  const onItemRegister = React3.useCallback(
-    (index) => (node) => {
-      if (!node) return;
-      itemMap.set(node, index);
-      if (resizeObserver) {
-        resizeObserver.observe(node);
-      }
-      if (positioner.get(index) === void 0) {
-        positioner.set(index, node.offsetHeight);
-      }
-    },
-    [itemMap, positioner, resizeObserver]
-  );
-  const contextValue = React3.useMemo(
-    () => ({
-      positioner,
-      resizeObserver,
-      columnWidth: positioner.columnWidth,
-      onItemRegister,
-      scrollTop,
-      windowHeight: size.height,
-      itemHeight,
-      overscan,
-      fallback,
-      isScrolling
-    }),
-    [positioner, resizeObserver, onItemRegister, scrollTop, size.height, itemHeight, overscan, fallback, isScrolling]
-  );
-  const RootPrimitive = asChild ? Slot : "div";
-  return /* @__PURE__ */ jsx(MasonryContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
-    RootPrimitive,
-    {
-      ...rootProps,
-      "data-slot": "masonry",
-      ref: composedRef,
-      style: {
-        position: "relative",
-        width: "100%",
-        height: "100%",
-        ...style
-      },
-      children: /* @__PURE__ */ jsx(MasonryViewport, { children })
-    }
-  ) });
-}
-
-export { Masonry, MasonryItem };