@neynar/ui 0.4.0 → 1.0.0

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/composite.js

@@ -0,0 +1,340 @@
+import formatErrorMessage from "../../../../utils/esm/formatErrorMessage.js";
+import { floor } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.js";
+import { stopEvent } from "./event.js";
+import { ARROW_UP, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT } from "./constants.js";
+function isDifferentGridRow(index, cols, prevRow) {
+  return Math.floor(index / cols) !== prevRow;
+}
+function isIndexOutOfListBounds(listRef, index) {
+  return index < 0 || index >= listRef.current.length;
+}
+function getMinListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef, {
+    disabledIndices
+  });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef, {
+    decrement: true,
+    startingIndex: listRef.current.length,
+    disabledIndices
+  });
+}
+function findNonDisabledListIndex(listRef, {
+  startingIndex = -1,
+  decrement = false,
+  disabledIndices,
+  amount = 1
+} = {}) {
+  let index = startingIndex;
+  do {
+    index += decrement ? -amount : amount;
+  } while (index >= 0 && index <= listRef.current.length - 1 && isListIndexDisabled(listRef, index, disabledIndices));
+  return index;
+}
+function getGridNavigatedIndex(listRef, {
+  event,
+  orientation,
+  loopFocus,
+  rtl,
+  cols,
+  disabledIndices,
+  minIndex,
+  maxIndex,
+  prevIndex,
+  stopEvent: stop = false
+}) {
+  let nextIndex = prevIndex;
+  const rows = [];
+  const rowIndexMap = {};
+  let hasRoleRow = false;
+  {
+    let currentRowEl = null;
+    let currentRowIndex = -1;
+    listRef.current.forEach((el, idx) => {
+      if (el == null) {
+        return;
+      }
+      const rowEl = el.closest('[role="row"]');
+      if (rowEl) {
+        hasRoleRow = true;
+      }
+      if (rowEl !== currentRowEl || currentRowIndex === -1) {
+        currentRowEl = rowEl;
+        currentRowIndex += 1;
+        rows[currentRowIndex] = [];
+      }
+      rows[currentRowIndex].push(idx);
+      rowIndexMap[idx] = currentRowIndex;
+    });
+  }
+  const hasDomRows = hasRoleRow && rows.length > 0 && rows.some((row) => row.length !== cols);
+  function navigateVertically(direction) {
+    if (!hasDomRows || prevIndex === -1) {
+      return void 0;
+    }
+    const currentRow = rowIndexMap[prevIndex];
+    if (currentRow == null) {
+      return void 0;
+    }
+    const colInRow = rows[currentRow].indexOf(prevIndex);
+    let nextRow = direction === "up" ? currentRow - 1 : currentRow + 1;
+    if (loopFocus) {
+      if (nextRow < 0) {
+        nextRow = rows.length - 1;
+      } else if (nextRow >= rows.length) {
+        nextRow = 0;
+      }
+    }
+    const visited = /* @__PURE__ */ new Set();
+    while (nextRow >= 0 && nextRow < rows.length && !visited.has(nextRow)) {
+      visited.add(nextRow);
+      const targetRow = rows[nextRow];
+      if (targetRow.length === 0) {
+        nextRow = direction === "up" ? nextRow - 1 : nextRow + 1;
+        continue;
+      }
+      const clampedCol = Math.min(colInRow, targetRow.length - 1);
+      for (let col = clampedCol; col >= 0; col -= 1) {
+        const candidate = targetRow[col];
+        if (!isListIndexDisabled(listRef, candidate, disabledIndices)) {
+          return candidate;
+        }
+      }
+      nextRow = direction === "up" ? nextRow - 1 : nextRow + 1;
+      if (loopFocus) {
+        if (nextRow < 0) {
+          nextRow = rows.length - 1;
+        } else if (nextRow >= rows.length) {
+          nextRow = 0;
+        }
+      }
+    }
+    return void 0;
+  }
+  if (event.key === ARROW_UP) {
+    const domBasedCandidate = navigateVertically("up");
+    if (domBasedCandidate !== void 0) {
+      if (stop) {
+        stopEvent(event);
+      }
+      nextIndex = domBasedCandidate;
+    } else {
+      if (stop) {
+        stopEvent(event);
+      }
+      if (prevIndex === -1) {
+        nextIndex = maxIndex;
+      } else {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: nextIndex,
+          amount: cols,
+          decrement: true,
+          disabledIndices
+        });
+        if (loopFocus && (prevIndex - cols < minIndex || nextIndex < 0)) {
+          const col = prevIndex % cols;
+          const maxCol = maxIndex % cols;
+          const offset = maxIndex - (maxCol - col);
+          if (maxCol === col) {
+            nextIndex = maxIndex;
+          } else {
+            nextIndex = maxCol > col ? offset : offset - cols;
+          }
+        }
+      }
+      if (isIndexOutOfListBounds(listRef, nextIndex)) {
+        nextIndex = prevIndex;
+      }
+    }
+  }
+  if (event.key === ARROW_DOWN) {
+    const domBasedCandidate = navigateVertically("down");
+    if (domBasedCandidate !== void 0) {
+      if (stop) {
+        stopEvent(event);
+      }
+      nextIndex = domBasedCandidate;
+    } else {
+      if (stop) {
+        stopEvent(event);
+      }
+      if (prevIndex === -1) {
+        nextIndex = minIndex;
+      } else {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex,
+          amount: cols,
+          disabledIndices
+        });
+        if (loopFocus && prevIndex + cols > maxIndex) {
+          nextIndex = findNonDisabledListIndex(listRef, {
+            startingIndex: prevIndex % cols - cols,
+            amount: cols,
+            disabledIndices
+          });
+        }
+      }
+      if (isIndexOutOfListBounds(listRef, nextIndex)) {
+        nextIndex = prevIndex;
+      }
+    }
+  }
+  if (orientation === "both") {
+    const prevRow = floor(prevIndex / cols);
+    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {
+      if (stop) {
+        stopEvent(event);
+      }
+      if (prevIndex % cols !== cols - 1) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex,
+          disabledIndices
+        });
+        if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
+          nextIndex = findNonDisabledListIndex(listRef, {
+            startingIndex: prevIndex - prevIndex % cols - 1,
+            disabledIndices
+          });
+        }
+      } else if (loopFocus) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex - prevIndex % cols - 1,
+          disabledIndices
+        });
+      }
+      if (isDifferentGridRow(nextIndex, cols, prevRow)) {
+        nextIndex = prevIndex;
+      }
+    }
+    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {
+      if (stop) {
+        stopEvent(event);
+      }
+      if (prevIndex % cols !== 0) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex,
+          decrement: true,
+          disabledIndices
+        });
+        if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
+          nextIndex = findNonDisabledListIndex(listRef, {
+            startingIndex: prevIndex + (cols - prevIndex % cols),
+            decrement: true,
+            disabledIndices
+          });
+        }
+      } else if (loopFocus) {
+        nextIndex = findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex + (cols - prevIndex % cols),
+          decrement: true,
+          disabledIndices
+        });
+      }
+      if (isDifferentGridRow(nextIndex, cols, prevRow)) {
+        nextIndex = prevIndex;
+      }
+    }
+    const lastRow = floor(maxIndex / cols) === prevRow;
+    if (isIndexOutOfListBounds(listRef, nextIndex)) {
+      if (loopFocus && lastRow) {
+        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(listRef, {
+          startingIndex: prevIndex - prevIndex % cols - 1,
+          disabledIndices
+        });
+      } else {
+        nextIndex = prevIndex;
+      }
+    }
+  }
+  return nextIndex;
+}
+function createGridCellMap(sizes, cols, dense) {
+  const cellMap = [];
+  let startIndex = 0;
+  sizes.forEach(({
+    width,
+    height
+  }, index) => {
+    if (width > cols) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(process.env.NODE_ENV !== "production" ? `[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns` : formatErrorMessage(29, index));
+      }
+    }
+    let itemPlaced = false;
+    if (dense) {
+      startIndex = 0;
+    }
+    while (!itemPlaced) {
+      const targetCells = [];
+      for (let i = 0; i < width; i += 1) {
+        for (let j = 0; j < height; j += 1) {
+          targetCells.push(startIndex + i + j * cols);
+        }
+      }
+      if (startIndex % cols + width <= cols && targetCells.every((cell) => cellMap[cell] == null)) {
+        targetCells.forEach((cell) => {
+          cellMap[cell] = index;
+        });
+        itemPlaced = true;
+      } else {
+        startIndex += 1;
+      }
+    }
+  });
+  return [...cellMap];
+}
+function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
+  if (index === -1) {
+    return -1;
+  }
+  const firstCellIndex = cellMap.indexOf(index);
+  const sizeItem = sizes[index];
+  switch (corner) {
+    case "tl":
+      return firstCellIndex;
+    case "tr":
+      if (!sizeItem) {
+        return firstCellIndex;
+      }
+      return firstCellIndex + sizeItem.width - 1;
+    case "bl":
+      if (!sizeItem) {
+        return firstCellIndex;
+      }
+      return firstCellIndex + (sizeItem.height - 1) * cols;
+    case "br":
+      return cellMap.lastIndexOf(index);
+    default:
+      return -1;
+  }
+}
+function getGridCellIndices(indices, cellMap) {
+  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);
+}
+function isListIndexDisabled(listRef, index, disabledIndices) {
+  if (typeof disabledIndices === "function") {
+    return disabledIndices(index);
+  }
+  if (disabledIndices) {
+    return disabledIndices.includes(index);
+  }
+  const element = listRef.current[index];
+  if (!element) {
+    return false;
+  }
+  return element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+export {
+  createGridCellMap,
+  findNonDisabledListIndex,
+  getGridCellIndexOfCorner,
+  getGridCellIndices,
+  getGridNavigatedIndex,
+  getMaxListIndex,
+  getMinListIndex,
+  isDifferentGridRow,
+  isIndexOutOfListBounds,
+  isListIndexDisabled
+};
+//# sourceMappingURL=composite.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/composite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/composite.js"],"sourcesContent":["import _formatErrorMessage from \"@base-ui/utils/formatErrorMessage\";\nimport { floor } from '@floating-ui/utils';\nimport { stopEvent } from \"./event.js\";\nimport { ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP } from \"./constants.js\";\nexport function isDifferentGridRow(index, cols, prevRow) {\n  return Math.floor(index / cols) !== prevRow;\n}\nexport function isIndexOutOfListBounds(listRef, index) {\n  return index < 0 || index >= listRef.current.length;\n}\nexport function getMinListIndex(listRef, disabledIndices) {\n  return findNonDisabledListIndex(listRef, {\n    disabledIndices\n  });\n}\nexport function getMaxListIndex(listRef, disabledIndices) {\n  return findNonDisabledListIndex(listRef, {\n    decrement: true,\n    startingIndex: listRef.current.length,\n    disabledIndices\n  });\n}\nexport function findNonDisabledListIndex(listRef, {\n  startingIndex = -1,\n  decrement = false,\n  disabledIndices,\n  amount = 1\n} = {}) {\n  let index = startingIndex;\n  do {\n    index += decrement ? -amount : amount;\n  } while (index >= 0 && index <= listRef.current.length - 1 && isListIndexDisabled(listRef, index, disabledIndices));\n  return index;\n}\nexport function getGridNavigatedIndex(listRef, {\n  event,\n  orientation,\n  loopFocus,\n  rtl,\n  cols,\n  disabledIndices,\n  minIndex,\n  maxIndex,\n  prevIndex,\n  stopEvent: stop = false\n}) {\n  let nextIndex = prevIndex;\n\n  // ---------------------------------------------------------------------------\n  // Detect row structure based on DOM. This works when items are grouped inside\n  // elements that declare `role=\"row\"` (e.g., Combobox.Row). We build a matrix\n  // where each entry is the array of item indices for that visual row. The\n  // algorithm gracefully falls back to regular `cols`-based handling when no\n  // row structure can be detected.\n  // ---------------------------------------------------------------------------\n  const rows = [];\n  const rowIndexMap = {};\n  let hasRoleRow = false;\n  {\n    let currentRowEl = null;\n    let currentRowIndex = -1;\n    listRef.current.forEach((el, idx) => {\n      if (el == null) {\n        return;\n      }\n      const rowEl = el.closest('[role=\"row\"]');\n      if (rowEl) {\n        hasRoleRow = true;\n      }\n      if (rowEl !== currentRowEl || currentRowIndex === -1) {\n        currentRowEl = rowEl;\n        currentRowIndex += 1;\n        rows[currentRowIndex] = [];\n      }\n      rows[currentRowIndex].push(idx);\n      rowIndexMap[idx] = currentRowIndex;\n    });\n  }\n  const hasDomRows = hasRoleRow && rows.length > 0 && rows.some(row => row.length !== cols);\n  function navigateVertically(direction) {\n    if (!hasDomRows || prevIndex === -1) {\n      return undefined;\n    }\n    const currentRow = rowIndexMap[prevIndex];\n    if (currentRow == null) {\n      return undefined;\n    }\n    const colInRow = rows[currentRow].indexOf(prevIndex);\n    let nextRow = direction === 'up' ? currentRow - 1 : currentRow + 1;\n    if (loopFocus) {\n      if (nextRow < 0) {\n        nextRow = rows.length - 1;\n      } else if (nextRow >= rows.length) {\n        nextRow = 0;\n      }\n    }\n    const visited = new Set();\n    while (nextRow >= 0 && nextRow < rows.length && !visited.has(nextRow)) {\n      visited.add(nextRow);\n      const targetRow = rows[nextRow];\n      if (targetRow.length === 0) {\n        nextRow = direction === 'up' ? nextRow - 1 : nextRow + 1;\n        continue;\n      }\n      const clampedCol = Math.min(colInRow, targetRow.length - 1);\n      // Start from the preferred column, fallback leftwards until first\n      // enabled item is found.\n      for (let col = clampedCol; col >= 0; col -= 1) {\n        const candidate = targetRow[col];\n        if (!isListIndexDisabled(listRef, candidate, disabledIndices)) {\n          return candidate;\n        }\n      }\n      // Row had no enabled items, move to next row in the same direction.\n      nextRow = direction === 'up' ? nextRow - 1 : nextRow + 1;\n      if (loopFocus) {\n        if (nextRow < 0) {\n          nextRow = rows.length - 1;\n        } else if (nextRow >= rows.length) {\n          nextRow = 0;\n        }\n      }\n    }\n    return undefined;\n  }\n  if (event.key === ARROW_UP) {\n    const domBasedCandidate = navigateVertically('up');\n    if (domBasedCandidate !== undefined) {\n      if (stop) {\n        stopEvent(event);\n      }\n      nextIndex = domBasedCandidate;\n    } else {\n      // fallback to original logic\n      if (stop) {\n        stopEvent(event);\n      }\n      if (prevIndex === -1) {\n        nextIndex = maxIndex;\n      } else {\n        nextIndex = findNonDisabledListIndex(listRef, {\n          startingIndex: nextIndex,\n          amount: cols,\n          decrement: true,\n          disabledIndices\n        });\n        if (loopFocus && (prevIndex - cols < minIndex || nextIndex < 0)) {\n          const col = prevIndex % cols;\n          const maxCol = maxIndex % cols;\n          const offset = maxIndex - (maxCol - col);\n          if (maxCol === col) {\n            nextIndex = maxIndex;\n          } else {\n            nextIndex = maxCol > col ? offset : offset - cols;\n          }\n        }\n      }\n      if (isIndexOutOfListBounds(listRef, nextIndex)) {\n        nextIndex = prevIndex;\n      }\n    }\n  }\n  if (event.key === ARROW_DOWN) {\n    const domBasedCandidate = navigateVertically('down');\n    if (domBasedCandidate !== undefined) {\n      if (stop) {\n        stopEvent(event);\n      }\n      nextIndex = domBasedCandidate;\n    } else {\n      if (stop) {\n        stopEvent(event);\n      }\n      if (prevIndex === -1) {\n        nextIndex = minIndex;\n      } else {\n        nextIndex = findNonDisabledListIndex(listRef, {\n          startingIndex: prevIndex,\n          amount: cols,\n          disabledIndices\n        });\n        if (loopFocus && prevIndex + cols > maxIndex) {\n          nextIndex = findNonDisabledListIndex(listRef, {\n            startingIndex: prevIndex % cols - cols,\n            amount: cols,\n            disabledIndices\n          });\n        }\n      }\n      if (isIndexOutOfListBounds(listRef, nextIndex)) {\n        nextIndex = prevIndex;\n      }\n    }\n  }\n\n  // Remains on the same row/column.\n  if (orientation === 'both') {\n    const prevRow = floor(prevIndex / cols);\n    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {\n      if (stop) {\n        stopEvent(event);\n      }\n      if (prevIndex % cols !== cols - 1) {\n        nextIndex = findNonDisabledListIndex(listRef, {\n          startingIndex: prevIndex,\n          disabledIndices\n        });\n        if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledListIndex(listRef, {\n            startingIndex: prevIndex - prevIndex % cols - 1,\n            disabledIndices\n          });\n        }\n      } else if (loopFocus) {\n        nextIndex = findNonDisabledListIndex(listRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      }\n      if (isDifferentGridRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {\n      if (stop) {\n        stopEvent(event);\n      }\n      if (prevIndex % cols !== 0) {\n        nextIndex = findNonDisabledListIndex(listRef, {\n          startingIndex: prevIndex,\n          decrement: true,\n          disabledIndices\n        });\n        if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledListIndex(listRef, {\n            startingIndex: prevIndex + (cols - prevIndex % cols),\n            decrement: true,\n            disabledIndices\n          });\n        }\n      } else if (loopFocus) {\n        nextIndex = findNonDisabledListIndex(listRef, {\n          startingIndex: prevIndex + (cols - prevIndex % cols),\n          decrement: true,\n          disabledIndices\n        });\n      }\n      if (isDifferentGridRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    const lastRow = floor(maxIndex / cols) === prevRow;\n    if (isIndexOutOfListBounds(listRef, nextIndex)) {\n      if (loopFocus && lastRow) {\n        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(listRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      } else {\n        nextIndex = prevIndex;\n      }\n    }\n  }\n  return nextIndex;\n}\n\n/** For each cell index, gets the item index that occupies that cell */\nexport function createGridCellMap(sizes, cols, dense) {\n  const cellMap = [];\n  let startIndex = 0;\n  sizes.forEach(({\n    width,\n    height\n  }, index) => {\n    if (width > cols) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(process.env.NODE_ENV !== \"production\" ? `[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns` : _formatErrorMessage(29, index));\n      }\n    }\n    let itemPlaced = false;\n    if (dense) {\n      startIndex = 0;\n    }\n    while (!itemPlaced) {\n      const targetCells = [];\n      for (let i = 0; i < width; i += 1) {\n        for (let j = 0; j < height; j += 1) {\n          targetCells.push(startIndex + i + j * cols);\n        }\n      }\n      if (startIndex % cols + width <= cols && targetCells.every(cell => cellMap[cell] == null)) {\n        targetCells.forEach(cell => {\n          cellMap[cell] = index;\n        });\n        itemPlaced = true;\n      } else {\n        startIndex += 1;\n      }\n    }\n  });\n\n  // convert into a non-sparse array\n  return [...cellMap];\n}\n\n/** Gets cell index of an item's corner or -1 when index is -1. */\nexport function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {\n  if (index === -1) {\n    return -1;\n  }\n  const firstCellIndex = cellMap.indexOf(index);\n  const sizeItem = sizes[index];\n  switch (corner) {\n    case 'tl':\n      return firstCellIndex;\n    case 'tr':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + sizeItem.width - 1;\n    case 'bl':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + (sizeItem.height - 1) * cols;\n    case 'br':\n      return cellMap.lastIndexOf(index);\n    default:\n      return -1;\n  }\n}\n\n/** Gets all cell indices that correspond to the specified indices */\nexport function getGridCellIndices(indices, cellMap) {\n  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);\n}\nexport function isListIndexDisabled(listRef, index, disabledIndices) {\n  if (typeof disabledIndices === 'function') {\n    return disabledIndices(index);\n  }\n  if (disabledIndices) {\n    return disabledIndices.includes(index);\n  }\n  const element = listRef.current[index];\n  if (!element) {\n    return false;\n  }\n  return element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';\n}"],"names":["_formatErrorMessage"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/constants.js

@@ -0,0 +1,19 @@
+const FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
+const ACTIVE_KEY = "active";
+const SELECTED_KEY = "selected";
+const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+const ARROW_LEFT = "ArrowLeft";
+const ARROW_RIGHT = "ArrowRight";
+const ARROW_UP = "ArrowUp";
+const ARROW_DOWN = "ArrowDown";
+export {
+  ACTIVE_KEY,
+  ARROW_DOWN,
+  ARROW_LEFT,
+  ARROW_RIGHT,
+  ARROW_UP,
+  FOCUSABLE_ATTRIBUTE,
+  SELECTED_KEY,
+  TYPEABLE_SELECTOR
+};
+//# sourceMappingURL=constants.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/constants.js"],"sourcesContent":["export const FOCUSABLE_ATTRIBUTE = 'data-base-ui-focusable';\nexport const ACTIVE_KEY = 'active';\nexport const SELECTED_KEY = 'selected';\nexport const TYPEABLE_SELECTOR = \"input:not([type='hidden']):not([disabled]),\" + \"[contenteditable]:not([contenteditable='false']),textarea:not([disabled])\";\nexport const ARROW_LEFT = 'ArrowLeft';\nexport const ARROW_RIGHT = 'ArrowRight';\nexport const ARROW_UP = 'ArrowUp';\nexport const ARROW_DOWN = 'ArrowDown';"],"names":[],"mappings":"AAAY,MAAC,sBAAsB;AACvB,MAAC,aAAa;AACd,MAAC,eAAe;AAChB,MAAC,oBAAoB;AACrB,MAAC,aAAa;AACd,MAAC,cAAc;AACf,MAAC,WAAW;AACZ,MAAC,aAAa;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/createAttribute.js

@@ -0,0 +1,7 @@
+function createAttribute(name) {
+  return `data-base-ui-${name}`;
+}
+export {
+  createAttribute
+};
+//# sourceMappingURL=createAttribute.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/createAttribute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAttribute.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/createAttribute.js"],"sourcesContent":["export function createAttribute(name) {\n  return `data-base-ui-${name}`;\n}"],"names":[],"mappings":"AAAO,SAAS,gBAAgB,MAAM;AACpC,SAAO,gBAAgB,IAAI;AAC7B;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/createEventEmitter.js

@@ -0,0 +1,21 @@
+function createEventEmitter() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    emit(event, data) {
+      map.get(event)?.forEach((listener) => listener(data));
+    },
+    on(event, listener) {
+      if (!map.has(event)) {
+        map.set(event, /* @__PURE__ */ new Set());
+      }
+      map.get(event).add(listener);
+    },
+    off(event, listener) {
+      map.get(event)?.delete(listener);
+    }
+  };
+}
+export {
+  createEventEmitter
+};
+//# sourceMappingURL=createEventEmitter.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/createEventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createEventEmitter.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/createEventEmitter.js"],"sourcesContent":["export function createEventEmitter() {\n  const map = new Map();\n  return {\n    emit(event, data) {\n      map.get(event)?.forEach(listener => listener(data));\n    },\n    on(event, listener) {\n      if (!map.has(event)) {\n        map.set(event, new Set());\n      }\n      map.get(event).add(listener);\n    },\n    off(event, listener) {\n      map.get(event)?.delete(listener);\n    }\n  };\n}"],"names":[],"mappings":"AAAO,SAAS,qBAAqB;AACnC,QAAM,MAAM,oBAAI,IAAG;AACnB,SAAO;AAAA,IACL,KAAK,OAAO,MAAM;AAChB,UAAI,IAAI,KAAK,GAAG,QAAQ,cAAY,SAAS,IAAI,CAAC;AAAA,IACpD;AAAA,IACA,GAAG,OAAO,UAAU;AAClB,UAAI,CAAC,IAAI,IAAI,KAAK,GAAG;AACnB,YAAI,IAAI,OAAO,oBAAI,IAAG,CAAE;AAAA,MAC1B;AACA,UAAI,IAAI,KAAK,EAAE,IAAI,QAAQ;AAAA,IAC7B;AAAA,IACA,IAAI,OAAO,UAAU;AACnB,UAAI,IAAI,KAAK,GAAG,OAAO,QAAQ;AAAA,IACjC;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/element.js

@@ -0,0 +1,89 @@
+import { isShadowRoot, isHTMLElement } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { isJSDOM } from "../../../../utils/esm/detectBrowser.js";
+import { TYPEABLE_SELECTOR, FOCUSABLE_ATTRIBUTE } from "./constants.js";
+function activeElement(doc) {
+  let element = doc.activeElement;
+  while (element?.shadowRoot?.activeElement != null) {
+    element = element.shadowRoot.activeElement;
+  }
+  return element;
+}
+function contains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  const rootNode = child.getRootNode?.();
+  if (parent.contains(child)) {
+    return true;
+  }
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+function getTarget(event) {
+  if ("composedPath" in event) {
+    return event.composedPath()[0];
+  }
+  return event.target;
+}
+function isEventTargetWithin(event, node) {
+  if (node == null) {
+    return false;
+  }
+  if ("composedPath" in event) {
+    return event.composedPath().includes(node);
+  }
+  const eventAgain = event;
+  return eventAgain.target != null && node.contains(eventAgain.target);
+}
+function isRootElement(element) {
+  return element.matches("html,body");
+}
+function getDocument(node) {
+  return node?.ownerDocument || document;
+}
+function isTypeableElement(element) {
+  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+function isTypeableCombobox(element) {
+  if (!element) {
+    return false;
+  }
+  return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+function matchesFocusVisible(element) {
+  if (!element || isJSDOM) {
+    return true;
+  }
+  try {
+    return element.matches(":focus-visible");
+  } catch (_e) {
+    return true;
+  }
+}
+function getFloatingFocusElement(floatingElement) {
+  if (!floatingElement) {
+    return null;
+  }
+  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${FOCUSABLE_ATTRIBUTE}]`) || floatingElement;
+}
+export {
+  activeElement,
+  contains,
+  getDocument,
+  getFloatingFocusElement,
+  getTarget,
+  isEventTargetWithin,
+  isRootElement,
+  isTypeableCombobox,
+  isTypeableElement,
+  matchesFocusVisible
+};
+//# sourceMappingURL=element.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"element.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/element.js"],"sourcesContent":["import { isHTMLElement, isShadowRoot } from '@floating-ui/utils/dom';\nimport { isJSDOM } from '@base-ui/utils/detectBrowser';\nimport { FOCUSABLE_ATTRIBUTE, TYPEABLE_SELECTOR } from \"./constants.js\";\nexport function activeElement(doc) {\n  let element = doc.activeElement;\n  while (element?.shadowRoot?.activeElement != null) {\n    element = element.shadowRoot.activeElement;\n  }\n  return element;\n}\nexport function contains(parent, child) {\n  if (!parent || !child) {\n    return false;\n  }\n  const rootNode = child.getRootNode?.();\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n\n  // then fallback to custom implementation with Shadow DOM support\n  if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n    while (next) {\n      if (parent === next) {\n        return true;\n      }\n      next = next.parentNode || next.host;\n    }\n  }\n\n  // Give up, the result is false\n  return false;\n}\nexport function getTarget(event) {\n  if ('composedPath' in event) {\n    return event.composedPath()[0];\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support\n  // `composedPath()`, but browsers without shadow DOM don't.\n  return event.target;\n}\nexport function isEventTargetWithin(event, node) {\n  if (node == null) {\n    return false;\n  }\n  if ('composedPath' in event) {\n    return event.composedPath().includes(node);\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't\n  const eventAgain = event;\n  return eventAgain.target != null && node.contains(eventAgain.target);\n}\nexport function isRootElement(element) {\n  return element.matches('html,body');\n}\nexport function getDocument(node) {\n  return node?.ownerDocument || document;\n}\nexport function isTypeableElement(element) {\n  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);\n}\nexport function isTypeableCombobox(element) {\n  if (!element) {\n    return false;\n  }\n  return element.getAttribute('role') === 'combobox' && isTypeableElement(element);\n}\nexport function matchesFocusVisible(element) {\n  // We don't want to block focus from working with `visibleOnly`\n  // (JSDOM doesn't match `:focus-visible` when the element has `:focus`)\n  if (!element || isJSDOM) {\n    return true;\n  }\n  try {\n    return element.matches(':focus-visible');\n  } catch (_e) {\n    return true;\n  }\n}\nexport function getFloatingFocusElement(floatingElement) {\n  if (!floatingElement) {\n    return null;\n  }\n  // Try to find the element that has `{...getFloatingProps()}` spread on it.\n  // This indicates the floating element is acting as a positioning wrapper, and\n  // so focus should be managed on the child element with the event handlers and\n  // aria props.\n  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${FOCUSABLE_ATTRIBUTE}]`) || floatingElement;\n}"],"names":[],"mappings":";;;AAGO,SAAS,cAAc,KAAK;AACjC,MAAI,UAAU,IAAI;AAClB,SAAO,SAAS,YAAY,iBAAiB,MAAM;AACjD,cAAU,QAAQ,WAAW;AAAA,EAC/B;AACA,SAAO;AACT;AACO,SAAS,SAAS,QAAQ,OAAO;AACtC,MAAI,CAAC,UAAU,CAAC,OAAO;AACrB,WAAO;AAAA,EACT;AACA,QAAM,WAAW,MAAM,cAAW;AAGlC,MAAI,OAAO,SAAS,KAAK,GAAG;AAC1B,WAAO;AAAA,EACT;AAGA,MAAI,YAAY,aAAa,QAAQ,GAAG;AACtC,QAAI,OAAO;AACX,WAAO,MAAM;AACX,UAAI,WAAW,MAAM;AACnB,eAAO;AAAA,MACT;AACA,aAAO,KAAK,cAAc,KAAK;AAAA,IACjC;AAAA,EACF;AAGA,SAAO;AACT;AACO,SAAS,UAAU,OAAO;AAC/B,MAAI,kBAAkB,OAAO;AAC3B,WAAO,MAAM,aAAY,EAAG,CAAC;AAAA,EAC/B;AAIA,SAAO,MAAM;AACf;AACO,SAAS,oBAAoB,OAAO,MAAM;AAC/C,MAAI,QAAQ,MAAM;AAChB,WAAO;AAAA,EACT;AACA,MAAI,kBAAkB,OAAO;AAC3B,WAAO,MAAM,eAAe,SAAS,IAAI;AAAA,EAC3C;AAGA,QAAM,aAAa;AACnB,SAAO,WAAW,UAAU,QAAQ,KAAK,SAAS,WAAW,MAAM;AACrE;AACO,SAAS,cAAc,SAAS;AACrC,SAAO,QAAQ,QAAQ,WAAW;AACpC;AACO,SAAS,YAAY,MAAM;AAChC,SAAO,MAAM,iBAAiB;AAChC;AACO,SAAS,kBAAkB,SAAS;AACzC,SAAO,cAAc,OAAO,KAAK,QAAQ,QAAQ,iBAAiB;AACpE;AACO,SAAS,mBAAmB,SAAS;AAC1C,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AACA,SAAO,QAAQ,aAAa,MAAM,MAAM,cAAc,kBAAkB,OAAO;AACjF;AACO,SAAS,oBAAoB,SAAS;AAG3C,MAAI,CAAC,WAAW,SAAS;AACvB,WAAO;AAAA,EACT;AACA,MAAI;AACF,WAAO,QAAQ,QAAQ,gBAAgB;AAAA,EACzC,SAAS,IAAI;AACX,WAAO;AAAA,EACT;AACF;AACO,SAAS,wBAAwB,iBAAiB;AACvD,MAAI,CAAC,iBAAiB;AACpB,WAAO;AAAA,EACT;AAKA,SAAO,gBAAgB,aAAa,mBAAmB,IAAI,kBAAkB,gBAAgB,cAAc,IAAI,mBAAmB,GAAG,KAAK;AAC5I;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/enqueueFocus.js

@@ -0,0 +1,23 @@
+let rafId = 0;
+function enqueueFocus(el, options = {}) {
+  const {
+    preventScroll = false,
+    cancelPrevious = true,
+    sync = false
+  } = options;
+  if (cancelPrevious) {
+    cancelAnimationFrame(rafId);
+  }
+  const exec = () => el?.focus({
+    preventScroll
+  });
+  if (sync) {
+    exec();
+  } else {
+    rafId = requestAnimationFrame(exec);
+  }
+}
+export {
+  enqueueFocus
+};
+//# sourceMappingURL=enqueueFocus.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/enqueueFocus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enqueueFocus.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/enqueueFocus.js"],"sourcesContent":["let rafId = 0;\nexport function enqueueFocus(el, options = {}) {\n  const {\n    preventScroll = false,\n    cancelPrevious = true,\n    sync = false\n  } = options;\n  if (cancelPrevious) {\n    cancelAnimationFrame(rafId);\n  }\n  const exec = () => el?.focus({\n    preventScroll\n  });\n  if (sync) {\n    exec();\n  } else {\n    rafId = requestAnimationFrame(exec);\n  }\n}"],"names":[],"mappings":"AAAA,IAAI,QAAQ;AACL,SAAS,aAAa,IAAI,UAAU,IAAI;AAC7C,QAAM;AAAA,IACJ,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,OAAO;AAAA,EACX,IAAM;AACJ,MAAI,gBAAgB;AAClB,yBAAqB,KAAK;AAAA,EAC5B;AACA,QAAM,OAAO,MAAM,IAAI,MAAM;AAAA,IAC3B;AAAA,EACJ,CAAG;AACD,MAAI,MAAM;AACR,SAAI;AAAA,EACN,OAAO;AACL,YAAQ,sBAAsB,IAAI;AAAA,EACpC;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/event.js

@@ -0,0 +1,44 @@
+import { isAndroid, isJSDOM } from "../../../../utils/esm/detectBrowser.js";
+function stopEvent(event) {
+  event.preventDefault();
+  event.stopPropagation();
+}
+function isReactEvent(event) {
+  return "nativeEvent" in event;
+}
+function isVirtualClick(event) {
+  if (event.mozInputSource === 0 && event.isTrusted) {
+    return true;
+  }
+  if (isAndroid && event.pointerType) {
+    return event.type === "click" && event.buttons === 1;
+  }
+  return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+  if (isJSDOM) {
+    return false;
+  }
+  return !isAndroid && event.width === 0 && event.height === 0 || isAndroid && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || // iOS VoiceOver returns 0.333• for width/height.
+  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
+}
+function isMouseLikePointerType(pointerType, strict) {
+  const values = ["mouse", "pen"];
+  if (!strict) {
+    values.push("", void 0);
+  }
+  return values.includes(pointerType);
+}
+function isClickLikeEvent(event) {
+  const type = event.type;
+  return type === "click" || type === "mousedown" || type === "keydown" || type === "keyup";
+}
+export {
+  isClickLikeEvent,
+  isMouseLikePointerType,
+  isReactEvent,
+  isVirtualClick,
+  isVirtualPointerEvent,
+  stopEvent
+};
+//# sourceMappingURL=event.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/event.js"],"sourcesContent":["import { isAndroid, isJSDOM } from '@base-ui/utils/detectBrowser';\nexport function stopEvent(event) {\n  event.preventDefault();\n  event.stopPropagation();\n}\nexport function isReactEvent(event) {\n  return 'nativeEvent' in event;\n}\n\n// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts\nexport function isVirtualClick(event) {\n  // FIXME: Firefox is now emitting a deprecation warning for `mozInputSource`.\n  // Try to find a workaround for this. `react-aria` source still has the check.\n  if (event.mozInputSource === 0 && event.isTrusted) {\n    return true;\n  }\n  if (isAndroid && event.pointerType) {\n    return event.type === 'click' && event.buttons === 1;\n  }\n  return event.detail === 0 && !event.pointerType;\n}\nexport function isVirtualPointerEvent(event) {\n  if (isJSDOM) {\n    return false;\n  }\n  return !isAndroid && event.width === 0 && event.height === 0 || isAndroid && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'mouse' ||\n  // iOS VoiceOver returns 0.333• for width/height.\n  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'touch';\n}\nexport function isMouseLikePointerType(pointerType, strict) {\n  // On some Linux machines with Chromium, mouse inputs return a `pointerType`\n  // of \"pen\": https://github.com/floating-ui/floating-ui/issues/2015\n  const values = ['mouse', 'pen'];\n  if (!strict) {\n    values.push('', undefined);\n  }\n  return values.includes(pointerType);\n}\nexport function isClickLikeEvent(event) {\n  const type = event.type;\n  return type === 'click' || type === 'mousedown' || type === 'keydown' || type === 'keyup';\n}"],"names":[],"mappings":";AACO,SAAS,UAAU,OAAO;AAC/B,QAAM,eAAc;AACpB,QAAM,gBAAe;AACvB;AACO,SAAS,aAAa,OAAO;AAClC,SAAO,iBAAiB;AAC1B;AAGO,SAAS,eAAe,OAAO;AAGpC,MAAI,MAAM,mBAAmB,KAAK,MAAM,WAAW;AACjD,WAAO;AAAA,EACT;AACA,MAAI,aAAa,MAAM,aAAa;AAClC,WAAO,MAAM,SAAS,WAAW,MAAM,YAAY;AAAA,EACrD;AACA,SAAO,MAAM,WAAW,KAAK,CAAC,MAAM;AACtC;AACO,SAAS,sBAAsB,OAAO;AAC3C,MAAI,SAAS;AACX,WAAO;AAAA,EACT;AACA,SAAO,CAAC,aAAa,MAAM,UAAU,KAAK,MAAM,WAAW,KAAK,aAAa,MAAM,UAAU,KAAK,MAAM,WAAW,KAAK,MAAM,aAAa,KAAK,MAAM,WAAW,KAAK,MAAM,gBAAgB;AAAA,EAE5L,MAAM,QAAQ,KAAK,MAAM,SAAS,KAAK,MAAM,aAAa,KAAK,MAAM,WAAW,KAAK,MAAM,gBAAgB;AAC7G;AACO,SAAS,uBAAuB,aAAa,QAAQ;AAG1D,QAAM,SAAS,CAAC,SAAS,KAAK;AAC9B,MAAI,CAAC,QAAQ;AACX,WAAO,KAAK,IAAI,MAAS;AAAA,EAC3B;AACA,SAAO,OAAO,SAAS,WAAW;AACpC;AACO,SAAS,iBAAiB,OAAO;AACtC,QAAM,OAAO,MAAM;AACnB,SAAO,SAAS,WAAW,SAAS,eAAe,SAAS,aAAa,SAAS;AACpF;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/getEmptyRootContext.js

@@ -0,0 +1,18 @@
+import { FloatingRootStore } from "../components/FloatingRootStore.js";
+import { PopupTriggerMap } from "../../utils/popups/popupTriggerMap.js";
+function getEmptyRootContext() {
+  return new FloatingRootStore({
+    open: false,
+    floatingElement: null,
+    referenceElement: null,
+    triggerElements: new PopupTriggerMap(),
+    floatingId: "",
+    nested: false,
+    noEmit: false,
+    onOpenChange: void 0
+  });
+}
+export {
+  getEmptyRootContext
+};
+//# sourceMappingURL=getEmptyRootContext.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/utils/getEmptyRootContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEmptyRootContext.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/utils/getEmptyRootContext.js"],"sourcesContent":["import { PopupTriggerMap } from \"../../utils/popups/index.js\";\nimport { FloatingRootStore } from \"../components/FloatingRootStore.js\";\nexport function getEmptyRootContext() {\n  return new FloatingRootStore({\n    open: false,\n    floatingElement: null,\n    referenceElement: null,\n    triggerElements: new PopupTriggerMap(),\n    floatingId: '',\n    nested: false,\n    noEmit: false,\n    onOpenChange: undefined\n  });\n}"],"names":[],"mappings":";;AAEO,SAAS,sBAAsB;AACpC,SAAO,IAAI,kBAAkB;AAAA,IAC3B,MAAM;AAAA,IACN,iBAAiB;AAAA,IACjB,kBAAkB;AAAA,IAClB,iBAAiB,IAAI,gBAAe;AAAA,IACpC,YAAY;AAAA,IACZ,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,cAAc;AAAA,EAClB,CAAG;AACH;","x_google_ignoreList":[0]}