kviewer 0.0.1

package/dist/runtime/composables/useViewerSearch.js

@@ -0,0 +1,418 @@
+import {
+  inject,
+  provide,
+  ref
+} from "vue";
+import {
+  findMatchesInText,
+  flattenMatchesByPage,
+  getRenderRange,
+  stepMatchIndex
+} from "./search-utils.js";
+const VIEWER_SEARCH_KEY = Symbol("kviewer-search");
+export function provideViewerSearch() {
+  const isOpen = ref(false);
+  const query = ref("");
+  const matchCase = ref(false);
+  const wholeWord = ref(false);
+  const highlightAll = ref(true);
+  const currentMatch = ref(0);
+  const totalMatches = ref(0);
+  const notFound = ref(false);
+  const pageLayers = /* @__PURE__ */ new Map();
+  const matchesByPage = /* @__PURE__ */ new Map();
+  let flattenedMatches = [];
+  let selectedGlobalIndex = -1;
+  let inputElement = null;
+  let _searchIndex = null;
+  let _scrollToPage = null;
+  function setSearchIndex(index) {
+    _searchIndex = index;
+  }
+  function setScrollToPage(fn) {
+    _scrollToPage = fn;
+  }
+  function getSortedPageNumbers() {
+    return [...pageLayers.keys()].sort((a, b) => a - b);
+  }
+  function ensureDivElement(binding, divIdx) {
+    const current = binding.textDivs[divIdx];
+    if (!current) return null;
+    if (typeof Node !== "undefined" && current.nodeType === Node.TEXT_NODE) {
+      const span = document.createElement("span");
+      const parent = current.parentNode;
+      if (!parent) return null;
+      parent.replaceChild(span, current);
+      binding.textDivs[divIdx] = span;
+      return span;
+    }
+    return current;
+  }
+  function clearPageHighlights(binding) {
+    for (let i = 0; i < binding.textDivs.length; i++) {
+      const div = ensureDivElement(binding, i);
+      if (!div) continue;
+      div.textContent = binding.sourceTextByDiv[i] ?? "";
+      div.className = "";
+    }
+  }
+  function convertPageMatches(pageMatches, sourceTextByDiv) {
+    if (pageMatches.length === 0 || sourceTextByDiv.length === 0) return [];
+    let i = 0;
+    let iIndex = 0;
+    const end = sourceTextByDiv.length - 1;
+    const converted = [];
+    for (const pageMatch of pageMatches) {
+      let matchIdx = pageMatch.index;
+      while (i !== end && matchIdx >= iIndex + sourceTextByDiv[i].length) {
+        iIndex += sourceTextByDiv[i].length;
+        i++;
+      }
+      const begin = {
+        divIdx: i,
+        offset: matchIdx - iIndex
+      };
+      matchIdx += pageMatch.length;
+      while (i !== end && matchIdx > iIndex + sourceTextByDiv[i].length) {
+        iIndex += sourceTextByDiv[i].length;
+        i++;
+      }
+      const endMatch = {
+        divIdx: i,
+        offset: matchIdx - iIndex
+      };
+      converted.push({ begin, end: endMatch });
+    }
+    return converted;
+  }
+  function appendTextToDiv(binding, divIdx, fromOffset, toOffset, className) {
+    const div = ensureDivElement(binding, divIdx);
+    if (!div) return null;
+    const sourceText = binding.sourceTextByDiv[divIdx] ?? "";
+    const content = toOffset === void 0 ? sourceText.slice(fromOffset) : sourceText.slice(fromOffset, toOffset);
+    const node = document.createTextNode(content);
+    if (!className) {
+      div.append(node);
+      return null;
+    }
+    const span = document.createElement("span");
+    span.className = `${className} appended`;
+    span.append(node);
+    div.append(span);
+    return className.includes("selected") ? span : null;
+  }
+  function beginText(binding, begin, className) {
+    const div = ensureDivElement(binding, begin.divIdx);
+    if (!div) return null;
+    div.textContent = "";
+    return appendTextToDiv(binding, begin.divIdx, 0, begin.offset, className);
+  }
+  function getSelectedLocation() {
+    if (selectedGlobalIndex < 0 || selectedGlobalIndex >= flattenedMatches.length) {
+      return null;
+    }
+    const selected = flattenedMatches[selectedGlobalIndex];
+    if (!selected) return null;
+    return {
+      pageNumber: selected.pageNumber,
+      matchIndex: selected.matchIndex
+    };
+  }
+  function renderHighlightsForPage(pageNumber, shouldScrollSelected) {
+    const binding = pageLayers.get(pageNumber);
+    if (!binding) return;
+    clearPageHighlights(binding);
+    if (!isOpen.value) return;
+    const pageMatches = matchesByPage.get(pageNumber) ?? [];
+    if (pageMatches.length === 0) return;
+    const selectedLocation = getSelectedLocation();
+    const isSelectedPage = selectedLocation?.pageNumber === pageNumber;
+    const selectedMatchIndex = isSelectedPage ? selectedLocation?.matchIndex ?? -1 : -1;
+    const range = getRenderRange(
+      pageMatches.length,
+      highlightAll.value,
+      isSelectedPage,
+      selectedMatchIndex
+    );
+    if (!range) return;
+    const convertedMatches = convertPageMatches(pageMatches, binding.sourceTextByDiv);
+    if (convertedMatches.length === 0) return;
+    let prevEnd = null;
+    let lastDivIdx = -1;
+    let lastOffset = -1;
+    for (let i = range.start; i < range.end; i++) {
+      const match = convertedMatches[i];
+      if (!match) continue;
+      const begin = match.begin;
+      if (begin.divIdx === lastDivIdx && begin.offset === lastOffset) {
+        continue;
+      }
+      lastDivIdx = begin.divIdx;
+      lastOffset = begin.offset;
+      const end = match.end;
+      const isSelected = isSelectedPage && i === selectedMatchIndex;
+      const highlightSuffix = isSelected ? " selected" : "";
+      let selectedSpan = null;
+      if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
+        if (prevEnd) {
+          appendTextToDiv(binding, prevEnd.divIdx, prevEnd.offset, void 0);
+        }
+        beginText(binding, begin);
+      } else {
+        appendTextToDiv(binding, prevEnd.divIdx, prevEnd.offset, begin.offset);
+      }
+      if (begin.divIdx === end.divIdx) {
+        selectedSpan = appendTextToDiv(
+          binding,
+          begin.divIdx,
+          begin.offset,
+          end.offset,
+          `highlight${highlightSuffix}`
+        );
+      } else {
+        selectedSpan = appendTextToDiv(
+          binding,
+          begin.divIdx,
+          begin.offset,
+          void 0,
+          `highlight begin${highlightSuffix}`
+        );
+        for (let mid = begin.divIdx + 1; mid < end.divIdx; mid++) {
+          const middleDiv = ensureDivElement(binding, mid);
+          if (!middleDiv) continue;
+          middleDiv.className = `highlight middle${highlightSuffix}`;
+        }
+        beginText(binding, end, `highlight end${highlightSuffix}`);
+      }
+      prevEnd = end;
+      if (isSelected && shouldScrollSelected && selectedSpan) {
+        selectedSpan.scrollIntoView({
+          block: "start",
+          inline: "center"
+        });
+      }
+    }
+    if (prevEnd) {
+      appendTextToDiv(binding, prevEnd.divIdx, prevEnd.offset, void 0);
+    }
+  }
+  function renderAllHighlights(shouldScrollSelected = false) {
+    for (const pageNumber of getSortedPageNumbers()) {
+      renderHighlightsForPage(pageNumber, shouldScrollSelected);
+    }
+  }
+  function clearAllHighlights() {
+    for (const binding of pageLayers.values()) {
+      clearPageHighlights(binding);
+    }
+  }
+  function updateCounters() {
+    totalMatches.value = flattenedMatches.length;
+    currentMatch.value = selectedGlobalIndex >= 0 ? selectedGlobalIndex + 1 : 0;
+    notFound.value = query.value.length > 0 && totalMatches.value === 0;
+  }
+  function recomputeMatches({ preferFirst = false, shouldScrollSelected = false } = {}) {
+    const selectedLocation = getSelectedLocation();
+    matchesByPage.clear();
+    flattenedMatches = [];
+    if (!query.value) {
+      selectedGlobalIndex = -1;
+      updateCounters();
+      if (isOpen.value) {
+        clearAllHighlights();
+      }
+      return;
+    }
+    if (_searchIndex) {
+      const allPageNumbers = [];
+      for (let i = 1; i <= _searchIndex.totalPages; i++) {
+        allPageNumbers.push(i);
+      }
+      for (const pageNumber of allPageNumbers) {
+        const text = _searchIndex.getPageText(pageNumber);
+        if (text === null) continue;
+        const pageMatches = findMatchesInText(text, query.value, {
+          matchCase: matchCase.value,
+          wholeWord: wholeWord.value
+        });
+        if (pageMatches.length > 0) {
+          matchesByPage.set(pageNumber, pageMatches);
+        }
+      }
+      flattenedMatches = flattenMatchesByPage(allPageNumbers, matchesByPage);
+    } else {
+      const pageNumbers = getSortedPageNumbers();
+      for (const pageNumber of pageNumbers) {
+        const binding = pageLayers.get(pageNumber);
+        if (!binding) continue;
+        const pageMatches = findMatchesInText(binding.fullText, query.value, {
+          matchCase: matchCase.value,
+          wholeWord: wholeWord.value
+        });
+        matchesByPage.set(pageNumber, pageMatches);
+      }
+      flattenedMatches = flattenMatchesByPage(pageNumbers, matchesByPage);
+    }
+    if (flattenedMatches.length === 0) {
+      selectedGlobalIndex = -1;
+    } else if (preferFirst) {
+      selectedGlobalIndex = 0;
+    } else if (selectedLocation) {
+      const preservedIndex = flattenedMatches.findIndex(
+        (entry) => entry.pageNumber === selectedLocation.pageNumber && entry.matchIndex === selectedLocation.matchIndex
+      );
+      selectedGlobalIndex = preservedIndex >= 0 ? preservedIndex : 0;
+    } else {
+      selectedGlobalIndex = 0;
+    }
+    updateCounters();
+    if (isOpen.value) {
+      renderAllHighlights(shouldScrollSelected);
+    }
+  }
+  function setPageBinding(pageNumber, textDivs, textContentItemsStr) {
+    const sourceTextByDiv = textDivs.map((div, index) => div.textContent ?? textContentItemsStr[index] ?? "");
+    pageLayers.set(pageNumber, {
+      textDivs,
+      sourceTextByDiv,
+      fullText: sourceTextByDiv.join("")
+    });
+    if (query.value) {
+      recomputeMatches();
+    } else if (isOpen.value) {
+      renderHighlightsForPage(pageNumber, false);
+    }
+  }
+  function open() {
+    if (isOpen.value) return;
+    isOpen.value = true;
+    renderAllHighlights();
+  }
+  function close() {
+    if (!isOpen.value) return;
+    isOpen.value = false;
+    clearAllHighlights();
+  }
+  function reset() {
+    close();
+    query.value = "";
+    matchCase.value = false;
+    wholeWord.value = false;
+    highlightAll.value = true;
+    currentMatch.value = 0;
+    totalMatches.value = 0;
+    notFound.value = false;
+    matchesByPage.clear();
+    flattenedMatches = [];
+    selectedGlobalIndex = -1;
+    pageLayers.clear();
+    inputElement = null;
+    _searchIndex = null;
+    _scrollToPage = null;
+  }
+  function setQuery(value) {
+    query.value = value;
+    recomputeMatches({ preferFirst: true, shouldScrollSelected: true });
+  }
+  function toggleMatchCase() {
+    matchCase.value = !matchCase.value;
+    recomputeMatches();
+  }
+  function toggleWholeWord() {
+    wholeWord.value = !wholeWord.value;
+    recomputeMatches();
+  }
+  function toggleHighlightAll() {
+    highlightAll.value = !highlightAll.value;
+    if (isOpen.value) {
+      renderAllHighlights();
+    }
+  }
+  function scrollToSelectedMatch() {
+    if (!_scrollToPage) return;
+    const location = getSelectedLocation();
+    if (!location) return;
+    if (!pageLayers.has(location.pageNumber)) {
+      _scrollToPage(location.pageNumber);
+    }
+  }
+  function findNext() {
+    selectedGlobalIndex = stepMatchIndex(selectedGlobalIndex, flattenedMatches.length, false);
+    updateCounters();
+    scrollToSelectedMatch();
+    if (isOpen.value) {
+      renderAllHighlights(true);
+    }
+  }
+  function findPrevious() {
+    selectedGlobalIndex = stepMatchIndex(selectedGlobalIndex, flattenedMatches.length, true);
+    updateCounters();
+    scrollToSelectedMatch();
+    if (isOpen.value) {
+      renderAllHighlights(true);
+    }
+  }
+  function registerPageLayer(pageNumber, textDivs, textContentItemsStr) {
+    setPageBinding(pageNumber, textDivs, textContentItemsStr);
+  }
+  function updatePageLayer(pageNumber, textDivs, textContentItemsStr) {
+    setPageBinding(pageNumber, textDivs, textContentItemsStr);
+  }
+  function unregisterPageLayer(pageNumber) {
+    const binding = pageLayers.get(pageNumber);
+    if (binding) {
+      clearPageHighlights(binding);
+    }
+    pageLayers.delete(pageNumber);
+    matchesByPage.delete(pageNumber);
+    if (query.value) {
+      recomputeMatches();
+    } else {
+      flattenedMatches = [];
+      selectedGlobalIndex = -1;
+      updateCounters();
+    }
+  }
+  function setInputElement(input) {
+    inputElement = input;
+  }
+  function focusInput() {
+    inputElement?.focus();
+    inputElement?.select();
+  }
+  const state = {
+    isOpen,
+    query,
+    matchCase,
+    wholeWord,
+    highlightAll,
+    currentMatch,
+    totalMatches,
+    notFound,
+    open,
+    close,
+    reset,
+    setQuery,
+    toggleMatchCase,
+    toggleWholeWord,
+    toggleHighlightAll,
+    findNext,
+    findPrevious,
+    registerPageLayer,
+    updatePageLayer,
+    unregisterPageLayer,
+    setInputElement,
+    focusInput,
+    setSearchIndex,
+    setScrollToPage
+  };
+  provide(VIEWER_SEARCH_KEY, state);
+  return state;
+}
+export function useViewerSearch() {
+  const state = inject(VIEWER_SEARCH_KEY);
+  if (!state) {
+    throw new Error("useViewerSearch() must be used inside a <KViewer> component");
+  }
+  return state;
+}

package/dist/runtime/composables/useViewerState.d.ts

@@ -0,0 +1,62 @@
+import { type Ref, type ShallowRef } from 'vue';
+import type { PDFDocumentProxy } from 'pdfjs-dist';
+import type { Painter } from '../annotation/engine/painter.js';
+import { AnnotationType, type IAnnotationStore, type StampDefinition, type SignatureData, type SignatureHandlers } from '../annotation/engine/types.js';
+import { type AnnotationHistory } from './useAnnotationHistory.js';
+import { type FitMode } from './viewMode.js';
+export type { FitMode, ViewMode } from './viewMode.js';
+export { mapViewModeToFitMode, normalizeZoom } from './viewMode.js';
+export type ActiveTool = 'hand' | 'marquee' | 'eraser' | AnnotationType;
+export interface ViewerState {
+    scale: Ref<number>;
+    scaleOptions: number[];
+    fitMode: Ref<FitMode>;
+    containerDimensions: Ref<{
+        width: number;
+        height: number;
+    }>;
+    pageDimensions: Ref<{
+        width: number;
+        height: number;
+    } | null>;
+    setFitMode: (mode: FitMode) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    setScale: (value: number) => void;
+    currentPage: Ref<number>;
+    totalPages: Ref<number>;
+    isLoading: Ref<boolean>;
+    activeTool: Ref<ActiveTool>;
+    doc: ShallowRef<PDFDocumentProxy | null>;
+    annotations: ShallowRef<Map<string, IAnnotationStore>>;
+    selectedAnnotation: Ref<IAnnotationStore | null>;
+    selectedAnnotations: Ref<IAnnotationStore[]>;
+    selectionRect: Ref<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    painter: ShallowRef<Painter | null>;
+    stamps: Ref<StampDefinition[]>;
+    activeStamp: Ref<StampDefinition | null>;
+    signatures: Ref<SignatureData[]>;
+    activeSignature: Ref<SignatureData | null>;
+    signatureHandlers: SignatureHandlers | null;
+    loadSignatures: () => Promise<void>;
+    saveSignature: (imageUrl: string) => Promise<SignatureData | null>;
+    deleteSignature: (id: string) => Promise<void>;
+    selectTool: (tool: ActiveTool, dataTransfer?: string | null) => void;
+    deleteAnnotation: (id: string) => void;
+    getAnnotations: () => IAnnotationStore[];
+    stylusMode: Ref<boolean>;
+    setStylusMode: (enabled: boolean) => void;
+    scrollToPage: (pageNumber: number) => void;
+    history: AnnotationHistory;
+}
+export interface ViewerStateProvider {
+    state: ViewerState;
+    setScrollToPageFn: (fn: (pageNumber: number) => void) => void;
+}
+export declare function provideViewerState(): ViewerStateProvider;
+export declare function useViewerState(): ViewerState;

package/dist/runtime/composables/useViewerState.js

@@ -0,0 +1,189 @@
+import {
+  ref,
+  shallowRef,
+  provide,
+  inject,
+  triggerRef,
+  watch
+} from "vue";
+import {
+  AnnotationType
+} from "../annotation/engine/types.js";
+import { annotationDefinitions } from "../annotation/engine/config.js";
+import { createAnnotationHistory } from "./useAnnotationHistory.js";
+import { computeScaleForFitMode } from "./viewMode.js";
+export { mapViewModeToFitMode, normalizeZoom } from "./viewMode.js";
+const VIEWER_STATE_KEY = Symbol("kviewer-state");
+const SCALE_OPTIONS = [0.25, 0.5, 0.75, 1, 1.25, 1.5, 2];
+export function provideViewerState() {
+  const scale = ref(1);
+  const currentPage = ref(1);
+  const totalPages = ref(0);
+  const isLoading = ref(false);
+  const activeTool = ref("hand");
+  const doc = shallowRef(null);
+  const annotations = shallowRef(/* @__PURE__ */ new Map());
+  const selectedAnnotation = ref(null);
+  const selectedAnnotations = ref([]);
+  const selectionRect = ref(null);
+  const painter = shallowRef(null);
+  const fitMode = ref("fit-width");
+  const containerDimensions = ref({ width: 0, height: 0 });
+  const pageDimensions = ref(null);
+  watch(
+    [fitMode, containerDimensions, pageDimensions],
+    ([mode, container, page]) => {
+      if (mode === "custom" || !page || !container.width || !container.height) return;
+      scale.value = computeScaleForFitMode(mode, container, page, scale.value);
+    }
+  );
+  function setFitMode(mode) {
+    fitMode.value = mode;
+  }
+  function setScale(value) {
+    fitMode.value = "custom";
+    scale.value = value;
+  }
+  function zoomIn() {
+    const currentIndex = SCALE_OPTIONS.indexOf(scale.value);
+    if (currentIndex >= 0 && currentIndex < SCALE_OPTIONS.length - 1) {
+      setScale(SCALE_OPTIONS[currentIndex + 1]);
+    } else if (currentIndex === -1) {
+      const next = SCALE_OPTIONS.find((s) => s > scale.value);
+      if (next !== void 0) setScale(next);
+    }
+  }
+  function zoomOut() {
+    const currentIndex = SCALE_OPTIONS.indexOf(scale.value);
+    if (currentIndex > 0) {
+      setScale(SCALE_OPTIONS[currentIndex - 1]);
+    } else if (currentIndex === -1) {
+      const prev = [...SCALE_OPTIONS].reverse().find((s) => s < scale.value);
+      if (prev !== void 0) setScale(prev);
+    }
+  }
+  const stylusMode = ref(false);
+  function setStylusMode(enabled) {
+    stylusMode.value = enabled;
+    if (painter.value) {
+      painter.value.refreshStylusMode();
+    }
+  }
+  const stamps = ref([]);
+  const activeStamp = ref(null);
+  const signatures = ref([]);
+  const activeSignature = ref(null);
+  let _signatureHandlers = null;
+  async function loadSignatures() {
+    if (!_signatureHandlers) return;
+    signatures.value = await _signatureHandlers.onLoad();
+  }
+  async function saveSignature(imageUrl) {
+    if (!_signatureHandlers) return null;
+    const sig = await _signatureHandlers.onSave(imageUrl);
+    signatures.value = [...signatures.value, sig];
+    return sig;
+  }
+  async function deleteSignature(id) {
+    if (!_signatureHandlers) return;
+    await _signatureHandlers.onDelete(id);
+    signatures.value = signatures.value.filter((s) => s.id !== id);
+    if (activeSignature.value?.id === id) activeSignature.value = null;
+  }
+  function selectTool(tool, dataTransfer) {
+    activeTool.value = tool;
+    selectedAnnotation.value = null;
+    selectedAnnotations.value = [];
+    selectionRect.value = null;
+    if (!painter.value) return;
+    if (typeof tool === "number") {
+      const annotationDef = annotationDefinitions.find(
+        (d) => d.type === tool
+      );
+      painter.value.activate(annotationDef ?? null, dataTransfer ?? null);
+    } else if (tool === "marquee") {
+      painter.value.activateMarquee();
+    } else if (tool === "eraser") {
+      painter.value.activateEraser();
+    } else {
+      const selectDef = annotationDefinitions.find(
+        (d) => d.type === AnnotationType.SELECT
+      );
+      painter.value.activate(selectDef ?? null, null);
+    }
+  }
+  function deleteAnnotation(id) {
+    if (painter.value) {
+      painter.value.delete(id, true);
+      annotations.value.delete(id);
+      triggerRef(annotations);
+      selectedAnnotation.value = null;
+      selectionRect.value = null;
+    }
+  }
+  function getAnnotations() {
+    return painter.value?.getData() ?? [];
+  }
+  let _scrollToPageFn = null;
+  function scrollToPage(pageNumber) {
+    _scrollToPageFn?.(pageNumber);
+  }
+  const history = createAnnotationHistory(annotations, painter);
+  const state = {
+    scale,
+    scaleOptions: SCALE_OPTIONS,
+    fitMode,
+    containerDimensions,
+    pageDimensions,
+    setFitMode,
+    zoomIn,
+    zoomOut,
+    setScale,
+    currentPage,
+    totalPages,
+    isLoading,
+    activeTool,
+    doc,
+    annotations,
+    selectedAnnotation,
+    selectedAnnotations,
+    selectionRect,
+    painter,
+    stamps,
+    activeStamp,
+    signatures,
+    activeSignature,
+    get signatureHandlers() {
+      return _signatureHandlers;
+    },
+    set signatureHandlers(v) {
+      _signatureHandlers = v;
+    },
+    loadSignatures,
+    saveSignature,
+    deleteSignature,
+    selectTool,
+    deleteAnnotation,
+    getAnnotations,
+    stylusMode,
+    setStylusMode,
+    scrollToPage,
+    history
+  };
+  provide(VIEWER_STATE_KEY, state);
+  return {
+    state,
+    setScrollToPageFn(fn) {
+      _scrollToPageFn = fn;
+    }
+  };
+}
+export function useViewerState() {
+  const state = inject(VIEWER_STATE_KEY);
+  if (!state) {
+    throw new Error(
+      "useViewerState() must be used inside a <KViewer> component"
+    );
+  }
+  return state;
+}

package/dist/runtime/composables/viewMode.d.ts

@@ -0,0 +1,11 @@
+export type ViewMode = 'fit-width' | 'fit-page' | 'zoom';
+export type FitMode = 'fit-width' | 'fit-page' | 'custom';
+export declare function mapViewModeToFitMode(mode: ViewMode): FitMode;
+export declare function normalizeZoom(zoom: number): number;
+export declare function computeScaleForFitMode(mode: FitMode, container: {
+    width: number;
+    height: number;
+}, page: {
+    width: number;
+    height: number;
+}, currentScale: number): number;

package/dist/runtime/composables/viewMode.js

@@ -0,0 +1,19 @@
+export function mapViewModeToFitMode(mode) {
+  return mode === "zoom" ? "custom" : mode;
+}
+export function normalizeZoom(zoom) {
+  if (!Number.isFinite(zoom) || zoom <= 0) {
+    return 1;
+  }
+  return zoom;
+}
+export function computeScaleForFitMode(mode, container, page, currentScale) {
+  switch (mode) {
+    case "fit-width":
+      return container.width / page.width;
+    case "fit-page":
+      return Math.min(container.width / page.width, container.height / page.height);
+    default:
+      return currentScale;
+  }
+}

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,3 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((_nuxtApp) => {
+});