kviewer 0.0.1

package/dist/runtime/components/Viewer.vue

@@ -0,0 +1,617 @@
+<template>
+  <div ref="viewerRoot" class="flex flex-col h-full">
+    <!-- Header slot: defaults to ViewerBar -->
+    <slot name="header">
+      <ViewerBar />
+    </slot>
+
+    <div class="relative flex-1 min-h-0">
+      <div
+        ref="scrollContainer"
+        class="absolute inset-0 overflow-auto bg-muted/50"
+        :class="{ 'overflow-hidden': isSinglePageMode }"
+      >
+        <ClientOnly>
+          <!-- Single-page-at-a-time mode -->
+          <div
+            v-if="isSinglePageMode && singlePageMeta"
+            class="flex flex-col items-center py-4"
+            :style="{ minHeight: '100%' }"
+          >
+            <div
+              :ref="(el) => onPageRef(singlePageMeta.pageNumber, el)"
+              :style="pageSlotStyle(singlePageMeta)"
+              class="kviewer-page-slot"
+            >
+              <div :style="pageRotationStyle(singlePageMeta)">
+                <PdfPage
+                  :key="singlePageMeta.pageNumber"
+                  :page-number="singlePageMeta.pageNumber"
+                  :page-meta="singlePageMeta"
+                  :scale="pageScale"
+                />
+              </div>
+            </div>
+          </div>
+
+          <!-- Continuous scroll — single-page layout -->
+          <div
+            v-else-if="pageSettings.layoutMode.value === 'single'"
+            class="flex flex-col items-center gap-4 py-4"
+          >
+            <div
+              v-for="meta in pageMetas"
+              :key="meta.pageNumber"
+              :ref="(el) => onPageRef(meta.pageNumber, el)"
+              :style="pageSlotStyle(meta)"
+              class="kviewer-page-slot"
+            >
+              <div :style="pageRotationStyle(meta)">
+                <PdfPage
+                  v-if="isPageRendered(meta.pageNumber)"
+                  :page-number="meta.pageNumber"
+                  :page-meta="meta"
+                  :scale="pageScale"
+                />
+              </div>
+            </div>
+          </div>
+
+          <!-- Continuous scroll — two-page (side-by-side) layout -->
+          <div
+            v-else
+            class="flex flex-col items-center gap-4 py-4"
+          >
+            <div
+              v-for="(pair, index) in pagedPairs"
+              :key="index"
+              class="flex gap-4"
+            >
+              <div
+                v-for="meta in pair"
+                :key="meta.pageNumber"
+                :ref="(el) => onPageRef(meta.pageNumber, el)"
+                :style="pageSlotStyle(meta)"
+                class="kviewer-page-slot"
+              >
+                <div :style="pageRotationStyle(meta)">
+                  <PdfPage
+                    v-if="isPageRendered(meta.pageNumber)"
+                    :page-number="meta.pageNumber"
+                    :page-meta="meta"
+                    :scale="pageScale"
+                  />
+                </div>
+              </div>
+            </div>
+          </div>
+        </ClientOnly>
+      </div>
+
+      <ClientOnly>
+        <FloatingPageIndicator :scroll-container="scrollContainer" />
+      </ClientOnly>
+    </div>
+
+    <!-- Footer slot: empty by default -->
+    <slot name="footer" />
+
+    <ClientOnly>
+      <AnnotationToolbar />
+    </ClientOnly>
+
+    <ClientOnly>
+      <FreeTextModal
+        v-model:open="freeTextModalOpen"
+        :default-color="freeTextDefaults.color"
+        :default-font-size="freeTextDefaults.fontSize"
+        :initial-text="freeTextDefaults.initialText"
+        @submit="onFreeTextSubmit"
+        @cancel="onFreeTextCancel"
+      />
+    </ClientOnly>
+  </div>
+</template>
+
+<script setup>
+import {
+  ref,
+  shallowRef,
+  computed,
+  watch,
+  nextTick,
+  triggerRef,
+  onMounted,
+  onBeforeUnmount
+} from "vue";
+import ViewerBar from "./ViewerBar.vue";
+import PdfPage from "./PdfPage.vue";
+import FreeTextModal from "./modals/FreeTextModal.vue";
+import AnnotationToolbar from "./AnnotationToolbar.vue";
+import FloatingPageIndicator from "./FloatingPageIndicator.vue";
+import { providePageSettings } from "../composables/usePageSettings";
+import { mapViewModeToFitMode, normalizeZoom, provideViewerState } from "../composables/useViewerState";
+import { provideViewerSearch } from "../composables/useViewerSearch";
+import { createAnnotationEngine } from "../composables/useAnnotationEngine";
+import { normalizeImportedAnnotations } from "../annotation/engine/import-normalize";
+import { getTimestampString } from "../annotation/engine/utils";
+import { downloadPdfBytes } from "../annotation/pdf-export/download";
+import { exportAnnotationsToPdf } from "../annotation/pdf-export/export";
+import { createPageVirtualization } from "../composables/usePageVirtualization";
+import { createPageProxyCache } from "../composables/usePageProxyCache";
+import { createSearchIndex } from "../composables/useSearchIndex";
+import { provideFormFields } from "../composables/useFormFields";
+import { isIPad, getTouchDistance, getTouchCenter, clampScale } from "../annotation/engine/input-device";
+const props = defineProps({
+  source: { type: null, required: true },
+  textLayer: { type: Boolean, required: false },
+  userName: { type: String, required: false, default: void 0 },
+  stamps: { type: Array, required: false, default: void 0 },
+  signatureHandlers: { type: Object, required: false, default: void 0 },
+  viewMode: { type: String, required: false, default: "fit-width" },
+  zoom: { type: Number, required: false, default: 1 },
+  active: { type: Boolean, required: false, default: true }
+});
+const viewerRoot = ref(null);
+const scrollContainer = ref(null);
+const { state: viewerState, setScrollToPageFn } = provideViewerState();
+const viewerSearch = provideViewerSearch();
+const formFieldsState = provideFormFields();
+const pageSettings = providePageSettings(viewerRoot);
+const virtualization = createPageVirtualization();
+setScrollToPageFn((pageNumber) => {
+  if (isSinglePageMode.value) {
+    viewerState.currentPage.value = pageNumber;
+  } else {
+    virtualization.scrollToPage(pageNumber);
+  }
+});
+const proxyCache = createPageProxyCache();
+const searchIndex = createSearchIndex();
+const doc = shallowRef(null);
+let painter = null;
+const pageMetas = virtualization.pageMetas;
+const { isPageRendered } = virtualization;
+watch(
+  virtualization.currentPage,
+  (page) => {
+    viewerState.currentPage.value = page;
+  }
+);
+function onPageRef(pageNumber, el) {
+  if (el) {
+    virtualization.observePage(pageNumber, el);
+  } else {
+    virtualization.unobservePage(pageNumber);
+  }
+}
+const pageScale = computed(() => {
+  return viewerState.scale.value;
+});
+const isSinglePageMode = computed(() => pageSettings.pageTransition.value === "single-page");
+const singlePageMeta = computed(() => {
+  const metas = pageMetas.value;
+  const page = viewerState.currentPage.value;
+  return metas[page - 1] ?? metas[0] ?? null;
+});
+const isRotatedSideways = computed(() => {
+  const r = pageSettings.rotation.value;
+  return r === 90 || r === 270;
+});
+function pageSlotStyle(meta) {
+  const s = pageScale.value;
+  if (isRotatedSideways.value) {
+    return {
+      width: meta.height * s + "px",
+      height: meta.width * s + "px"
+    };
+  }
+  return {
+    width: meta.width * s + "px",
+    height: meta.height * s + "px"
+  };
+}
+function pageRotationStyle(meta) {
+  const r = pageSettings.rotation.value;
+  if (r === 0) return {};
+  const s = pageScale.value;
+  const w = meta.width * s;
+  const h = meta.height * s;
+  if (r === 90) {
+    return {
+      transform: `rotate(90deg) translateY(-${h}px)`,
+      transformOrigin: "top left",
+      width: w + "px",
+      height: h + "px"
+    };
+  }
+  if (r === 180) {
+    return {
+      transform: `rotate(180deg)`,
+      transformOrigin: "center center",
+      width: w + "px",
+      height: h + "px"
+    };
+  }
+  return {
+    transform: `rotate(270deg) translateX(-${w}px)`,
+    transformOrigin: "top left",
+    width: w + "px",
+    height: h + "px"
+  };
+}
+const pagedPairs = computed(() => {
+  const metas = pageMetas.value;
+  const pairs = [];
+  for (let i = 0; i < metas.length; i += 2) {
+    if (i + 1 < metas.length) {
+      pairs.push([metas[i], metas[i + 1]]);
+    } else {
+      pairs.push([metas[i]]);
+    }
+  }
+  return pairs;
+});
+const freeTextModalOpen = ref(false);
+const freeTextDefaults = ref({ color: "#ff0000", fontSize: 18 });
+let freeTextResolve = null;
+function onRequestTextInput(opts) {
+  return new Promise((resolve) => {
+    freeTextDefaults.value = {
+      color: opts.defaultColor,
+      fontSize: opts.defaultFontSize,
+      initialText: opts.initialText
+    };
+    freeTextResolve = resolve;
+    freeTextModalOpen.value = true;
+  });
+}
+function onFreeTextSubmit(result) {
+  freeTextModalOpen.value = false;
+  freeTextResolve?.(result);
+  freeTextResolve = null;
+}
+function onFreeTextCancel() {
+  freeTextModalOpen.value = false;
+  freeTextResolve?.({
+    inputValue: freeTextDefaults.value.initialText ?? "",
+    color: freeTextDefaults.value.color,
+    fontSize: freeTextDefaults.value.fontSize,
+    cancelled: true
+  });
+  freeTextResolve = null;
+}
+async function loadDocument() {
+  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  if (!pdfjs.GlobalWorkerOptions.workerSrc) {
+    const workerModule = await import("pdfjs-dist/legacy/build/pdf.worker.min.mjs?url");
+    pdfjs.GlobalWorkerOptions.workerSrc = workerModule.default;
+  }
+  const source = props.source;
+  const loadingTask = pdfjs.getDocument(
+    source
+  );
+  const pdfDoc = await loadingTask.promise;
+  doc.value = pdfDoc;
+  viewerState.doc.value = pdfDoc;
+  viewerState.totalPages.value = pdfDoc.numPages;
+  proxyCache.setDocument(pdfDoc);
+  await virtualization.init(pdfDoc, scrollContainer.value);
+  const metas = virtualization.pageMetas.value;
+  if (metas.length > 0) {
+    viewerState.pageDimensions.value = {
+      width: metas[0].width,
+      height: metas[0].height
+    };
+  }
+  viewerSearch.setScrollToPage((pageNumber) => {
+    virtualization.scrollToPage(pageNumber);
+  });
+  searchIndex.buildIndex(pdfDoc).then(() => {
+    viewerSearch.setSearchIndex({
+      getPageText: searchIndex.getPageText,
+      totalPages: pdfDoc.numPages
+    });
+  });
+}
+let resizeObserver = null;
+function ensurePdfExtension(fileName) {
+  return fileName.toLowerCase().endsWith(".pdf") ? fileName : `${fileName}.pdf`;
+}
+function getSourceBaseName() {
+  if (typeof props.source !== "string" || props.source.length === 0) {
+    return "annotated";
+  }
+  try {
+    const url = new URL(props.source, window.location.href);
+    const path = url.pathname;
+    const name = path.split("/").pop() || "";
+    const withoutExtension = name.replace(/\.[^/.]+$/, "");
+    return withoutExtension || "annotated";
+  } catch {
+    const noQuery = props.source.split(/[?#]/)[0] || "";
+    const name = noQuery.split("/").pop() || "";
+    const withoutExtension = name.replace(/\.[^/.]+$/, "");
+    return withoutExtension || "annotated";
+  }
+}
+function resolveExportFileName(fileName) {
+  if (fileName && fileName.trim().length > 0) {
+    return ensurePdfExtension(fileName.trim());
+  }
+  const baseName = getSourceBaseName();
+  return `${baseName}_${getTimestampString()}.pdf`;
+}
+async function exportPdf(options = {}) {
+  if (!doc.value) {
+    throw new Error("Cannot export PDF before document is loaded");
+  }
+  if (!painter) {
+    throw new Error("Cannot export PDF before annotation engine is initialized");
+  }
+  const mergedOptions = {
+    flatten: false,
+    download: false,
+    preserveOriginalAnnotations: false,
+    ...options
+  };
+  const pdfData = await doc.value.getData();
+  const annotations = painter.getData();
+  const formFieldValues = formFieldsState.getAllFieldValues();
+  const bytes = await exportAnnotationsToPdf({
+    pdfData,
+    annotations,
+    options: mergedOptions,
+    formFieldValues
+  });
+  if (mergedOptions.download) {
+    downloadPdfBytes(bytes, resolveExportFileName(mergedOptions.fileName));
+  }
+  return bytes;
+}
+async function importAnnotations(annotations, options) {
+  const mode = options?.mode ?? "replace";
+  const normalized = normalizeImportedAnnotations(
+    annotations,
+    props.userName ?? "User"
+  );
+  if (!painter) {
+    return { loaded: 0, skipped: normalized.skipped + normalized.annotations.length };
+  }
+  if (mode === "replace") {
+    painter.replaceAnnotations(normalized.annotations);
+    viewerState.history.reset();
+  } else {
+    painter.mergeAnnotations(normalized.annotations);
+  }
+  viewerState.annotations.value = new Map(
+    painter.getData().map((annotation) => [annotation.id, annotation])
+  );
+  triggerRef(viewerState.annotations);
+  viewerState.selectedAnnotation.value = null;
+  viewerState.selectedAnnotations.value = [];
+  viewerState.selectionRect.value = null;
+  return {
+    loaded: normalized.annotations.length,
+    skipped: normalized.skipped
+  };
+}
+function getKonvaCanvasState() {
+  return painter?.getCanvasState() ?? {};
+}
+let pinchActive = false;
+let pinchStartDistance = 0;
+let pinchStartScale = 1;
+let pinchCurrentRatio = 1;
+let pinchOriginX = 0;
+let pinchOriginY = 0;
+let pinchStartViewportX = 0;
+let pinchStartViewportY = 0;
+let pinchCurrentViewportX = 0;
+let pinchCurrentViewportY = 0;
+function getPinchTarget() {
+  return scrollContainer.value?.firstElementChild;
+}
+function onPinchTouchStart(e) {
+  if (!viewerState.stylusMode.value) return;
+  if (e.touches.length === 2) {
+    const sc = scrollContainer.value;
+    const scRect = sc.getBoundingClientRect();
+    const center = getTouchCenter(e.touches[0], e.touches[1]);
+    pinchActive = true;
+    pinchStartDistance = getTouchDistance(e.touches[0], e.touches[1]);
+    pinchStartScale = viewerState.scale.value;
+    pinchCurrentRatio = 1;
+    pinchStartViewportX = center.x - scRect.left;
+    pinchStartViewportY = center.y - scRect.top;
+    pinchCurrentViewportX = pinchStartViewportX;
+    pinchCurrentViewportY = pinchStartViewportY;
+    pinchOriginX = pinchStartViewportX + sc.scrollLeft;
+    pinchOriginY = pinchStartViewportY + sc.scrollTop;
+    const target = getPinchTarget();
+    if (target) {
+      target.style.transformOrigin = `${pinchOriginX}px ${pinchOriginY}px`;
+      target.style.willChange = "transform";
+    }
+  }
+}
+function onPinchTouchMove(e) {
+  if (!viewerState.stylusMode.value || !pinchActive || e.touches.length < 2) return;
+  e.preventDefault();
+  const sc = scrollContainer.value;
+  if (!sc) return;
+  const scRect = sc.getBoundingClientRect();
+  const currentDistance = getTouchDistance(e.touches[0], e.touches[1]);
+  pinchCurrentRatio = currentDistance / pinchStartDistance;
+  const clamped = clampScale(pinchStartScale * pinchCurrentRatio);
+  pinchCurrentRatio = clamped / pinchStartScale;
+  const center = getTouchCenter(e.touches[0], e.touches[1]);
+  pinchCurrentViewportX = center.x - scRect.left;
+  pinchCurrentViewportY = center.y - scRect.top;
+  const target = getPinchTarget();
+  if (target) target.style.transform = `scale(${pinchCurrentRatio})`;
+  sc.scrollLeft = pinchOriginX * pinchCurrentRatio - pinchCurrentViewportX;
+  sc.scrollTop = pinchOriginY * pinchCurrentRatio - pinchCurrentViewportY;
+}
+function onPinchTouchEnd(e) {
+  if (e.touches.length < 2 && pinchActive) {
+    pinchActive = false;
+    const target = getPinchTarget();
+    if (target) {
+      target.style.transform = "";
+      target.style.willChange = "";
+    }
+    const finalScale = clampScale(pinchStartScale * pinchCurrentRatio);
+    if (Math.abs(finalScale - pinchStartScale) > 0.01) {
+      const layoutRatio = finalScale / pinchStartScale;
+      const newScrollLeft = pinchOriginX * layoutRatio - pinchCurrentViewportX;
+      const newScrollTop = pinchOriginY * layoutRatio - pinchCurrentViewportY;
+      viewerState.setScale(finalScale);
+      nextTick(() => {
+        const sc = scrollContainer.value;
+        if (sc) {
+          sc.scrollLeft = newScrollLeft;
+          sc.scrollTop = newScrollTop;
+        }
+      });
+    }
+    pinchCurrentRatio = 1;
+  }
+}
+let wheelCooldown = false;
+function onSinglePageWheel(event) {
+  if (!isSinglePageMode.value) return;
+  event.preventDefault();
+  if (wheelCooldown) return;
+  wheelCooldown = true;
+  setTimeout(() => {
+    wheelCooldown = false;
+  }, 300);
+  const total = viewerState.totalPages.value;
+  const cur = viewerState.currentPage.value;
+  if (event.deltaY > 0 && cur < total) {
+    viewerState.currentPage.value = cur + 1;
+  } else if (event.deltaY < 0 && cur > 1) {
+    viewerState.currentPage.value = cur - 1;
+  }
+}
+function onGlobalKeydown(event) {
+  if (!props.active) return;
+  if (isSinglePageMode.value) {
+    const total = viewerState.totalPages.value;
+    const cur = viewerState.currentPage.value;
+    if ((event.key === "ArrowDown" || event.key === "PageDown") && cur < total) {
+      event.preventDefault();
+      viewerState.currentPage.value = cur + 1;
+      return;
+    }
+    if ((event.key === "ArrowUp" || event.key === "PageUp") && cur > 1) {
+      event.preventDefault();
+      viewerState.currentPage.value = cur - 1;
+      return;
+    }
+  }
+  const isFindShortcut = (event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey && event.key.toLowerCase() === "f";
+  if (isFindShortcut) {
+    event.preventDefault();
+    viewerSearch.open();
+    nextTick(() => {
+      viewerSearch.focusInput();
+    });
+    return;
+  }
+  if (event.key === "Escape" && viewerSearch.isOpen.value) {
+    event.preventDefault();
+    viewerSearch.close();
+  }
+}
+onMounted(() => {
+  painter = createAnnotationEngine(viewerState, {
+    userName: props.userName,
+    onRequestTextInput
+  });
+  viewerState.selectTool(viewerState.activeTool.value);
+  if (props.stamps) viewerState.stamps.value = props.stamps;
+  if (props.signatureHandlers) {
+    viewerState.signatureHandlers = props.signatureHandlers;
+    viewerState.loadSignatures();
+  }
+  if (scrollContainer.value) {
+    resizeObserver = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry) {
+        viewerState.containerDimensions.value = {
+          width: entry.contentRect.width - 40,
+          height: entry.contentRect.height
+        };
+      }
+    });
+    resizeObserver.observe(scrollContainer.value);
+    scrollContainer.value.addEventListener("scroll", () => {
+      viewerState.selectionRect.value = null;
+    }, { passive: true });
+    scrollContainer.value.addEventListener("wheel", onSinglePageWheel, { passive: false });
+    scrollContainer.value.addEventListener("touchstart", onPinchTouchStart, { passive: true });
+    scrollContainer.value.addEventListener("touchmove", onPinchTouchMove, { passive: false });
+    scrollContainer.value.addEventListener("touchend", onPinchTouchEnd, { passive: true });
+    scrollContainer.value.addEventListener("touchcancel", onPinchTouchEnd, { passive: true });
+  }
+  if (isIPad()) {
+    viewerState.setStylusMode(true);
+  }
+  loadDocument();
+  window.addEventListener("keydown", onGlobalKeydown);
+});
+watch(
+  () => props.source,
+  () => {
+    viewerSearch.reset();
+    formFieldsState.reset();
+    searchIndex.destroy();
+    virtualization.destroy();
+    proxyCache.clear();
+    doc.value?.destroy();
+    loadDocument();
+  }
+);
+watch(
+  [() => props.viewMode, () => props.zoom],
+  ([newViewMode, newZoom]) => {
+    if (newViewMode === "zoom") {
+      viewerState.setScale(normalizeZoom(newZoom));
+      return;
+    }
+    viewerState.setFitMode(mapViewModeToFitMode(newViewMode));
+  },
+  { immediate: true }
+);
+watch(
+  () => props.stamps,
+  (newStamps) => {
+    viewerState.stamps.value = newStamps ?? [];
+  }
+);
+onBeforeUnmount(() => {
+  window.removeEventListener("keydown", onGlobalKeydown);
+  scrollContainer.value?.removeEventListener("wheel", onSinglePageWheel);
+  scrollContainer.value?.removeEventListener("touchstart", onPinchTouchStart);
+  scrollContainer.value?.removeEventListener("touchmove", onPinchTouchMove);
+  scrollContainer.value?.removeEventListener("touchend", onPinchTouchEnd);
+  scrollContainer.value?.removeEventListener("touchcancel", onPinchTouchEnd);
+  resizeObserver?.disconnect();
+  viewerSearch.reset();
+  searchIndex.destroy();
+  virtualization.destroy();
+  proxyCache.clear();
+  painter?.destroy();
+  doc.value?.destroy();
+});
+defineExpose({
+  getAnnotations: () => painter?.getData() ?? [],
+  importAnnotations,
+  exportPdf,
+  getKonvaCanvasState,
+  getFormFieldValues: () => formFieldsState.getAllFieldValues(),
+  setFormFieldValue: (fieldName, value) => formFieldsState.setFieldValueByName(fieldName, value)
+});
+</script>

package/dist/runtime/components/Viewer.vue.d.ts

@@ -0,0 +1,45 @@
+import { type ViewMode } from '../composables/useViewerState.js';
+import type { IAnnotationStore, StampDefinition, SignatureHandlers } from '../annotation/engine/types.js';
+import { type ExportPdfOptions } from '../annotation/pdf-export/export.js';
+type __VLS_Props = {
+    source: string | Uint8Array | object;
+    textLayer?: boolean;
+    userName?: string;
+    stamps?: StampDefinition[];
+    signatureHandlers?: SignatureHandlers;
+    viewMode?: ViewMode;
+    zoom?: number;
+    /** When false, global keyboard shortcuts (e.g. Cmd+F) are suppressed. Used by ViewerTabs to prevent hidden viewers from capturing input. */
+    active?: boolean;
+};
+declare function exportPdf(options?: ExportPdfOptions): Promise<Uint8Array>;
+type ImportMode = 'replace' | 'merge';
+declare function importAnnotations(annotations: IAnnotationStore[], options?: {
+    mode?: ImportMode;
+}): Promise<{
+    loaded: number;
+    skipped: number;
+}>;
+declare function getKonvaCanvasState(): Record<number, string>;
+declare var __VLS_1: {}, __VLS_40: {};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    footer?: (props: typeof __VLS_40) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    getAnnotations: () => IAnnotationStore[];
+    importAnnotations: typeof importAnnotations;
+    exportPdf: typeof exportPdf;
+    getKonvaCanvasState: typeof getKonvaCanvasState;
+    getFormFieldValues: () => import("../annotation/engine/types.js").FormFieldValue[];
+    setFormFieldValue: (fieldName: string, value: string | boolean | string[]) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ViewerBar.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;