nuvox 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -1,8 +1,23 @@
 # Changelog
 
 All notable changes to this project are documented here.
+
 Format loosely follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [0.1.6]
+
+### Added
+
+* Added new components: `Kanban`, `SearchBar`, `Image`, `Gallery`, `Lightbox`, `VideoPlayer`, `AudioPlayer`, `PDFViewer`, `ScrollArea`, and `StepWizard`.
+* Expanded the component library to 55+ components.
+* Expanded the icon library to 500+ icons.
+
+### Fixed
+
+* Fixed various CSS and theming issues across multiple components.
+* Fixed styling and behavior issues in `Tabs`, `Sidebar`, and `DropdownMenu`.
+* Improved consistency and reliability across components and themes.
+
 ## [0.1.5]
 
 ### Added

package/dist/{chunk-NC2NEPPE.js → chunk-HAMPWL7I.js}

@@ -155,7 +155,7 @@ var light = defineTheme({
     "2xl": "0 28px 56px rgba(0,0,0,0.16)",
     inner: "inset 0 1px 2px rgba(0,0,0,0.05)"
   },
-  elevation: { dropdown: 1e3, popover: 1100, modal: 1200, toast: 1300, tooltip: 1400 },
+  elevation: { dropdown: 1050, popover: 1060, modal: 1e3, toast: 1200, tooltip: 1100 },
   motion: {
     durationFast: "120ms",
     durationNormal: "200ms",
@@ -228,7 +228,7 @@ var dark = defineTheme({
     "2xl": "0 28px 56px rgba(0,0,0,0.65)",
     inner: "inset 0 1px 2px rgba(0,0,0,0.4)"
   },
-  elevation: { dropdown: 1e3, popover: 1100, modal: 1200, toast: 1300, tooltip: 1400 },
+  elevation: { dropdown: 1050, popover: 1060, modal: 1e3, toast: 1200, tooltip: 1100 },
   motion: {
     durationFast: "120ms",
     durationNormal: "200ms",
@@ -312,7 +312,7 @@ var glass = defineTheme({
     "2xl": "0 32px 80px rgba(0,0,0,0.18)",
     inner: "inset 0 1px 0 rgba(255,255,255,0.4)"
   },
-  elevation: { dropdown: 1e3, popover: 1100, modal: 1200, toast: 1300, tooltip: 1400 },
+  elevation: { dropdown: 1050, popover: 1060, modal: 1e3, toast: 1200, tooltip: 1100 },
   motion: {
     // Slightly slower/softer than light/dark — matches "everything floats".
     durationFast: "160ms",
@@ -1089,6 +1089,132 @@ function getSelectAllState(totalCount, selectedCount) {
   return "some";
 }
 
+// src/core/kanban.ts
+var DRAG_START_THRESHOLD_PX = 4;
+function resolveKanbanState(props) {
+  return { compact: props.compact ?? false };
+}
+function getBoardClasses(state, className) {
+  return ["nx-kanban", state.compact && "nx-kanban--compact", className].filter(Boolean).join(" ");
+}
+function getColumnClasses(isDropTarget, isDragging, className) {
+  return [
+    "nx-kanban__column",
+    isDropTarget && "nx-kanban__column--drop-target",
+    isDragging && "nx-kanban__column--dragging",
+    className
+  ].filter(Boolean).join(" ");
+}
+function getColumnCountClasses(overLimit) {
+  return ["nx-kanban__column-count", overLimit && "nx-kanban__column-count--over-limit"].filter(Boolean).join(" ");
+}
+function getCardWrapperClasses(opts, className) {
+  return [
+    "nx-kanban__card",
+    opts.isPointerDragging && "nx-kanban__card--dragging",
+    opts.isPickedUp && "nx-kanban__card--picked-up",
+    opts.disabled && "nx-kanban__card--disabled",
+    className
+  ].filter(Boolean).join(" ");
+}
+function findCardLocation(value, cardId) {
+  for (const column of value.columns) {
+    const index = column.cardIds.indexOf(cardId);
+    if (index !== -1) return { columnId: column.id, index };
+  }
+  return null;
+}
+function removeCard(value, cardId) {
+  const location = findCardLocation(value, cardId);
+  if (!location) return value;
+  return {
+    columns: value.columns.map(
+      (column) => column.id === location.columnId ? { ...column, cardIds: column.cardIds.filter((id) => id !== cardId) } : column
+    )
+  };
+}
+function moveCard(value, target) {
+  const location = findCardLocation(value, target.cardId);
+  const destExists = value.columns.some((column) => column.id === target.toColumnId);
+  if (!location || !destExists) return value;
+  const withoutCard = value.columns.map(
+    (column) => column.cardIds.includes(target.cardId) ? { ...column, cardIds: column.cardIds.filter((id) => id !== target.cardId) } : column
+  );
+  return {
+    columns: withoutCard.map((column) => {
+      if (column.id !== target.toColumnId) return column;
+      const clampedIndex = Math.max(0, Math.min(target.toIndex, column.cardIds.length));
+      const cardIds = [...column.cardIds];
+      cardIds.splice(clampedIndex, 0, target.cardId);
+      return { ...column, cardIds };
+    })
+  };
+}
+function getAdjacentColumnId(value, columnId, direction) {
+  const index = value.columns.findIndex((column) => column.id === columnId);
+  if (index === -1) return null;
+  return value.columns[index + direction]?.id ?? null;
+}
+function getKeyboardMoveTarget(value, cardId, direction) {
+  const location = findCardLocation(value, cardId);
+  if (!location) return null;
+  const column = value.columns.find((c) => c.id === location.columnId);
+  if (!column) return null;
+  if (direction === "up" || direction === "down") {
+    const toIndex2 = direction === "up" ? location.index - 1 : location.index + 1;
+    if (toIndex2 < 0 || toIndex2 > column.cardIds.length - 1) return null;
+    return { cardId, toColumnId: location.columnId, toIndex: toIndex2 };
+  }
+  const adjacentColumnId = getAdjacentColumnId(value, location.columnId, direction === "prev" ? -1 : 1);
+  if (!adjacentColumnId) return null;
+  const destColumn = value.columns.find((c) => c.id === adjacentColumnId);
+  if (!destColumn) return null;
+  const toIndex = Math.min(location.index, destColumn.cardIds.length);
+  return { cardId, toColumnId: adjacentColumnId, toIndex };
+}
+function computeDropIndex(pointerY, cardRects) {
+  for (let i = 0; i < cardRects.length; i++) {
+    const midpoint = (cardRects[i].top + cardRects[i].bottom) / 2;
+    if (pointerY < midpoint) return i;
+  }
+  return cardRects.length;
+}
+function computeDropColumn(pointerX, pointerY, columns) {
+  for (const column of columns) {
+    if (pointerX >= column.left && pointerX <= column.right && pointerY >= column.top && pointerY <= column.bottom) {
+      return column.id;
+    }
+  }
+  return null;
+}
+function moveColumn(value, target) {
+  const fromIndex = value.columns.findIndex((c) => c.id === target.columnId);
+  if (fromIndex === -1) return value;
+  const columns = [...value.columns];
+  const [moved] = columns.splice(fromIndex, 1);
+  const clampedIndex = Math.max(0, Math.min(target.toIndex, columns.length));
+  columns.splice(clampedIndex, 0, moved);
+  return { columns };
+}
+function removeColumn(value, columnId) {
+  if (!value.columns.some((c) => c.id === columnId)) return value;
+  return { columns: value.columns.filter((c) => c.id !== columnId) };
+}
+function getColumnKeyboardMoveTarget(value, columnId, direction) {
+  const fromIndex = value.columns.findIndex((c) => c.id === columnId);
+  if (fromIndex === -1) return null;
+  const toIndex = direction === "prev" ? fromIndex - 1 : fromIndex + 1;
+  if (toIndex < 0 || toIndex > value.columns.length - 1) return null;
+  return { columnId, toIndex };
+}
+function computeColumnDropIndex(pointerX, columnRects) {
+  for (let i = 0; i < columnRects.length; i++) {
+    const midpoint = (columnRects[i].left + columnRects[i].right) / 2;
+    if (pointerX < midpoint) return i;
+  }
+  return columnRects.length;
+}
+
 // src/core/code-highlight.ts
 function tokenizeFlat(source, grammar) {
   const tokens = [];
@@ -1829,6 +1955,358 @@ function getRichTextEditorClasses(state) {
   ].filter(Boolean).join(" ");
 }
 
+// src/core/gallery.ts
+function resolveGalleryState(props) {
+  return {
+    layout: props.layout ?? "grid",
+    columns: props.columns ?? 3,
+    gap: props.gap,
+    targetRowHeight: props.targetRowHeight ?? 220
+  };
+}
+function getGalleryClasses(state, className) {
+  return ["nx-gallery", `nx-gallery--${state.layout}`, className].filter(Boolean).join(" ");
+}
+function getGalleryStyle(state) {
+  const style = {};
+  if (state.gap) style.gap = state.gap;
+  if (state.layout === "grid" || state.layout === "masonry") {
+    style["--nx-gallery-columns"] = String(state.columns);
+  }
+  return style;
+}
+function aspectRatioFromDims(width, height) {
+  if (!width || !height || width <= 0 || height <= 0) return 1;
+  return width / height;
+}
+function computeJustifiedRows(aspectRatios, containerWidth, targetRowHeight, gap) {
+  if (aspectRatios.length === 0 || containerWidth <= 0 || targetRowHeight <= 0) return [];
+  const rows = [];
+  let rowIndices = [];
+  let rowNaturalWidths = [];
+  let rowWidthSum = 0;
+  function flushRow(scale) {
+    if (rowIndices.length === 0) return;
+    const gapsWidth = gap * (rowIndices.length - 1);
+    const availableWidth = containerWidth - gapsWidth;
+    const naturalTotal = rowWidthSum;
+    const scaleFactor = scale ? availableWidth / naturalTotal : 1;
+    rows.push({
+      indices: rowIndices,
+      height: targetRowHeight * scaleFactor,
+      widths: rowNaturalWidths.map((w) => w * scaleFactor)
+    });
+    rowIndices = [];
+    rowNaturalWidths = [];
+    rowWidthSum = 0;
+  }
+  for (let i = 0; i < aspectRatios.length; i++) {
+    const naturalWidth = aspectRatios[i] * targetRowHeight;
+    const gapsWidth = gap * rowIndices.length;
+    if (rowIndices.length > 0 && rowWidthSum + naturalWidth + gapsWidth > containerWidth) {
+      flushRow(true);
+    }
+    rowIndices.push(i);
+    rowNaturalWidths.push(naturalWidth);
+    rowWidthSum += naturalWidth;
+  }
+  const finalGapsWidth = gap * (rowIndices.length - 1);
+  const overflows = rowWidthSum + finalGapsWidth > containerWidth;
+  flushRow(overflows);
+  return rows;
+}
+
+// src/core/slider.ts
+function isRangeValue(value) {
+  return Array.isArray(value);
+}
+function toThumbs(value) {
+  return isRangeValue(value) ? [value[0], value[1]] : [value];
+}
+function fromThumbs(thumbs, like) {
+  return isRangeValue(like) ? [thumbs[0], thumbs[1]] : thumbs[0];
+}
+function resolveSliderState(props) {
+  return {
+    // ?? not || (CONTRACT.md Rule 3) — an explicit min={0} must not
+    // be discarded (it already is the default, but a future
+    // negative-range default would make this the exact bug Rule 3
+    // guards against).
+    min: props.min ?? 0,
+    max: props.max ?? 100,
+    step: props.step ?? 1,
+    isDisabled: props.disabled ?? false,
+    size: props.size ?? "md"
+  };
+}
+function clampAndSnap(value, state) {
+  const { min, max, step } = state;
+  const clamped = Math.min(Math.max(value, min), max);
+  if (step <= 0) return clamped;
+  const steps = Math.round((clamped - min) / step);
+  const snapped = min + steps * step;
+  return Math.min(Math.max(snapped, min), max);
+}
+function valueToPercent(value, min, max) {
+  if (max === min) return 0;
+  return (value - min) / (max - min) * 100;
+}
+function percentToValue(percent, min, max) {
+  return min + percent / 100 * (max - min);
+}
+function clampRangeThumb(thumbs, index, next, minGap = 0) {
+  if (index === 0) return Math.min(next, thumbs[1] - minGap);
+  return Math.max(next, thumbs[0] + minGap);
+}
+function nearestThumbIndex(thumbs, targetValue) {
+  const distLow = Math.abs(thumbs[0] - targetValue);
+  const distHigh = Math.abs(thumbs[1] - targetValue);
+  return distHigh < distLow ? 1 : 0;
+}
+var STEP_KEYS_UP = /* @__PURE__ */ new Set(["ArrowRight", "ArrowUp"]);
+var STEP_KEYS_DOWN = /* @__PURE__ */ new Set(["ArrowLeft", "ArrowDown"]);
+function getKeyboardValue(key, current, state) {
+  const bigStep = Math.min(state.step * 10, state.max - state.min);
+  if (STEP_KEYS_UP.has(key)) return clampAndSnap(current + state.step, state);
+  if (STEP_KEYS_DOWN.has(key)) return clampAndSnap(current - state.step, state);
+  if (key === "PageUp") return clampAndSnap(current + bigStep, state);
+  if (key === "PageDown") return clampAndSnap(current - bigStep, state);
+  if (key === "Home") return state.min;
+  if (key === "End") return state.max;
+  return null;
+}
+function getRootClasses(state, isRange, showValueLabel, className) {
+  return [
+    "nx-slider",
+    `nx-slider--${state.size}`,
+    isRange && "nx-slider--range",
+    state.isDisabled && "nx-slider--disabled",
+    // The value-label bubble floats above the thumb (see
+    // Slider.css) — with no room reserved for it, it overflows
+    // .nx-slider's own box and lands on whatever's above it in
+    // .nx-field, which for a slider with a `label` is the label
+    // text itself. This adds the top margin the bubble actually
+    // needs instead of relying on .nx-field's generic 4px gap.
+    showValueLabel && "nx-slider--with-value-label",
+    className
+  ].filter(Boolean).join(" ");
+}
+function getThumbAriaProps(input) {
+  return {
+    role: "slider",
+    "aria-valuemin": input.min,
+    "aria-valuemax": input.max,
+    "aria-valuenow": input.value,
+    "aria-valuetext": input.valueText,
+    "aria-orientation": "horizontal",
+    "aria-disabled": input.isDisabled || void 0,
+    "aria-labelledby": input.labelledBy,
+    tabIndex: input.isDisabled ? -1 : 0
+  };
+}
+
+// src/core/media.ts
+var PLAYBACK_RATES = [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2];
+function formatMediaTime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "0:00";
+  const total = Math.floor(seconds);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const paddedS = String(s).padStart(2, "0");
+  if (h > 0) return `${h}:${String(m).padStart(2, "0")}:${paddedS}`;
+  return `${m}:${paddedS}`;
+}
+function clampVolume(volume) {
+  return clampAndSnap(volume, { min: 0, max: 1, step: 0 });
+}
+function positionToTime(clientX, trackRect, duration) {
+  if (trackRect.width <= 0 || !Number.isFinite(duration) || duration <= 0) return 0;
+  const rawPercent = (clientX - trackRect.left) / trackRect.width * 100;
+  const percent = clampAndSnap(rawPercent, { min: 0, max: 100, step: 0 });
+  return percentToValue(percent, 0, duration);
+}
+function positionToRatio(clientX, trackRect) {
+  return clampVolume(positionToTime(clientX, trackRect, 1));
+}
+function getBufferedPercent(bufferedEnd, duration) {
+  if (!Number.isFinite(duration) || duration <= 0) return 0;
+  return clampAndSnap(bufferedEnd / duration * 100, { min: 0, max: 100, step: 0 });
+}
+function getProgressPercent(currentTime, duration) {
+  return getBufferedPercent(currentTime, duration);
+}
+function recoverDuration(media, restoreTo, onDuration, giveUpMs = 4e3, pollMs = 100) {
+  function isKnown(duration) {
+    return Number.isFinite(duration) && duration > 0;
+  }
+  if (isKnown(media.duration)) {
+    onDuration(media.duration);
+    return () => {
+    };
+  }
+  let settled = false;
+  let pollHandle;
+  let giveUpHandle;
+  function cleanup() {
+    media.removeEventListener("timeupdate", handleResolved);
+    media.removeEventListener("seeked", handleResolved);
+    media.removeEventListener("durationchange", handleResolved);
+    media.removeEventListener("error", handleError);
+    if (pollHandle !== void 0) clearInterval(pollHandle);
+    if (giveUpHandle !== void 0) clearTimeout(giveUpHandle);
+  }
+  function finish(resolvedDuration, restore) {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    if (restore) media.currentTime = restoreTo;
+    onDuration(resolvedDuration);
+  }
+  function handleResolved() {
+    if (isKnown(media.duration)) finish(media.duration, true);
+  }
+  function handleError() {
+    finish(0, false);
+  }
+  media.addEventListener("timeupdate", handleResolved);
+  media.addEventListener("seeked", handleResolved);
+  media.addEventListener("durationchange", handleResolved);
+  media.addEventListener("error", handleError);
+  pollHandle = setInterval(() => {
+    if (isKnown(media.duration)) finish(media.duration, true);
+  }, pollMs);
+  giveUpHandle = setTimeout(() => finish(0, false), giveUpMs);
+  media.currentTime = 1e101;
+  return cleanup;
+}
+function getSeekAriaProps(currentTime, duration) {
+  return {
+    role: "slider",
+    "aria-label": "Seek",
+    "aria-valuemin": 0,
+    "aria-valuemax": Math.max(duration, 0),
+    "aria-valuenow": Math.min(Math.max(currentTime, 0), Math.max(duration, 0)),
+    "aria-valuetext": formatMediaTime(currentTime)
+  };
+}
+function getVolumeAriaProps(volume, muted) {
+  const pct = Math.round(clampVolume(volume) * 100);
+  return {
+    role: "slider",
+    "aria-label": "Volume",
+    "aria-valuemin": 0,
+    "aria-valuemax": 100,
+    "aria-valuenow": muted ? 0 : pct,
+    "aria-valuetext": muted ? "Muted" : `${pct}%`
+  };
+}
+function getPlayButtonAriaProps(isPlaying) {
+  return { "aria-label": isPlaying ? "Pause" : "Play" };
+}
+function getMuteButtonAriaProps(isMuted) {
+  return { "aria-label": isMuted ? "Unmute" : "Mute", "aria-pressed": isMuted };
+}
+function isEffectivelyMuted(volume, muted) {
+  return muted || volume <= 0;
+}
+var SKIP_SECONDS = 10;
+var LABELED_SKIP_SECONDS = [5, 10, 15, 30];
+function hasLabeledSkipIcon(seconds) {
+  return LABELED_SKIP_SECONDS.includes(seconds);
+}
+function resolveSkipSeconds(skipSeconds) {
+  if (skipSeconds === void 0) return SKIP_SECONDS;
+  if (!Number.isFinite(skipSeconds) || skipSeconds <= 0) return SKIP_SECONDS;
+  return skipSeconds;
+}
+function skipTime(currentTime, duration, deltaSeconds) {
+  const max = Number.isFinite(duration) && duration > 0 ? duration : Infinity;
+  return Math.min(Math.max(currentTime + deltaSeconds, 0), max);
+}
+function getSkipButtonAriaProps(deltaSeconds) {
+  return { "aria-label": deltaSeconds < 0 ? `Back ${Math.abs(deltaSeconds)} seconds` : `Forward ${deltaSeconds} seconds` };
+}
+function resolveMediaTransport(props) {
+  const showNext = props.onNext !== void 0;
+  const showPrevious = props.onPrevious !== void 0;
+  return {
+    skipSeconds: resolveSkipSeconds(props.skipSeconds),
+    showNext,
+    showPrevious,
+    nextDisabled: showNext && (props.hasNext ?? true) === false,
+    previousDisabled: showPrevious && (props.hasPrevious ?? true) === false
+  };
+}
+function getTrackButtonAriaProps(direction) {
+  return { "aria-label": direction === "next" ? "Next track" : "Previous track" };
+}
+function getMediaKeyAction(key) {
+  switch (key) {
+    case " ":
+    case "Spacebar":
+      return "toggle-play";
+    case "ArrowLeft":
+      return "seek-back";
+    case "ArrowRight":
+      return "seek-forward";
+    case "ArrowUp":
+      return "volume-up";
+    case "ArrowDown":
+      return "volume-down";
+    default:
+      return null;
+  }
+}
+
+// src/core/pdf-viewer.ts
+function resolvePdfViewerState(props) {
+  return {
+    initialPage: props.initialPage ?? 1,
+    initialScale: props.initialScale ?? "auto",
+    minScale: props.minScale ?? 0.5,
+    maxScale: props.maxScale ?? 3,
+    scaleStep: props.scaleStep ?? 0.25
+  };
+}
+function getPdfViewerClasses(className) {
+  return ["nx-pdf-viewer", className].filter(Boolean).join(" ");
+}
+function clampPage(page) {
+  return Math.max(Math.round(page), 1);
+}
+function clampScale(scale, min, max) {
+  return Math.min(Math.max(scale, min), max);
+}
+function resolveZoomBase(scale, fitScale) {
+  return scale === "auto" ? fitScale : scale;
+}
+function zoomIn(scale, step, max, fitScale = 1) {
+  return clampScale(resolveZoomBase(scale, fitScale) + step, 0, max);
+}
+function zoomOut(scale, step, min, fitScale = 1) {
+  return clampScale(resolveZoomBase(scale, fitScale) - step, min, Infinity);
+}
+function isZoomAtMin(scale, min) {
+  return scale !== "auto" && scale <= min;
+}
+function isZoomAtMax(scale, max) {
+  return scale !== "auto" && scale >= max;
+}
+function estimateFitScale(iframeWidthPx, pageWidthPt = 612) {
+  if (iframeWidthPx <= 0 || pageWidthPt <= 0) return 1;
+  const pageWidthPx = pageWidthPt * (96 / 72);
+  return iframeWidthPx / pageWidthPx;
+}
+function formatZoomPercent(scale) {
+  return scale === "auto" ? "Fit" : `${Math.round(scale * 100)}%`;
+}
+function buildPdfSrc(src, page, scale) {
+  const base = src.split("#")[0];
+  const zoomParam = scale === "auto" ? "page-width" : Math.round(scale * 100);
+  return `${base}#page=${clampPage(page)}&zoom=${zoomParam}`;
+}
+
 export {
   defineTheme,
   TOKEN_CATEGORIES,
@@ -1895,6 +2373,23 @@ export {
   getNextSortDirection,
   getSortAriaProps,
   getSelectAllState,
+  DRAG_START_THRESHOLD_PX,
+  resolveKanbanState,
+  getBoardClasses,
+  getColumnClasses,
+  getColumnCountClasses,
+  getCardWrapperClasses,
+  findCardLocation,
+  removeCard,
+  moveCard,
+  getAdjacentColumnId,
+  getKeyboardMoveTarget,
+  computeDropIndex,
+  computeDropColumn,
+  moveColumn,
+  removeColumn,
+  getColumnKeyboardMoveTarget,
+  computeColumnDropIndex,
   LANGUAGE_LABELS,
   normalizeLanguage,
   nuvoxHighlight,
@@ -1908,6 +2403,55 @@ export {
   undoHistory,
   redoHistory,
   resolveRichTextEditorState,
-  getRichTextEditorClasses
+  getRichTextEditorClasses,
+  resolveGalleryState,
+  getGalleryClasses,
+  getGalleryStyle,
+  aspectRatioFromDims,
+  computeJustifiedRows,
+  isRangeValue,
+  toThumbs,
+  fromThumbs,
+  resolveSliderState,
+  clampAndSnap,
+  valueToPercent,
+  percentToValue,
+  clampRangeThumb,
+  nearestThumbIndex,
+  getKeyboardValue,
+  getRootClasses,
+  getThumbAriaProps,
+  PLAYBACK_RATES,
+  formatMediaTime,
+  clampVolume,
+  positionToTime,
+  positionToRatio,
+  getBufferedPercent,
+  getProgressPercent,
+  recoverDuration,
+  getSeekAriaProps,
+  getVolumeAriaProps,
+  getPlayButtonAriaProps,
+  getMuteButtonAriaProps,
+  isEffectivelyMuted,
+  SKIP_SECONDS,
+  LABELED_SKIP_SECONDS,
+  hasLabeledSkipIcon,
+  resolveSkipSeconds,
+  skipTime,
+  getSkipButtonAriaProps,
+  resolveMediaTransport,
+  getTrackButtonAriaProps,
+  getMediaKeyAction,
+  resolvePdfViewerState,
+  getPdfViewerClasses,
+  clampPage,
+  zoomIn,
+  zoomOut,
+  isZoomAtMin,
+  isZoomAtMax,
+  estimateFitScale,
+  formatZoomPercent,
+  buildPdfSrc
 };
-//# sourceMappingURL=chunk-NC2NEPPE.js.map
+//# sourceMappingURL=chunk-HAMPWL7I.js.map