@embedpdf/vue 0.0.0-stage → 3.0.0-next.15

package/dist/runtime/capabilities.d.ts

@@ -0,0 +1,52 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { CapabilityToken, EventHook } from '@embedpdf/core';
+/**
+ * Like {@link useCapability}, but a ref that is null while the token can't
+ * resolve: no plugin, no document, or a document that isn't ready yet. It
+ * changes when the subtree's document does, so a `watch` on it rebinds.
+ */
+export declare function useOptionalCapability<Capability>(token: MaybeRefOrGetter<CapabilityToken<Capability>>): Readonly<Ref<Capability | null>>;
+/**
+ * The capability a subtree resolves to, as a ref: the document's while one is
+ * ready, else the stand-in for a document plugin. A token no plugin provides
+ * throws here, at setup: that is a setup mistake.
+ */
+export declare function useCapabilityRef<Capability>(token: MaybeRefOrGetter<CapabilityToken<Capability>>): Readonly<Ref<Capability>>;
+/**
+ * A plugin's API for this subtree: `const stage = useCapability(StageToken)`,
+ * then `stage.zoomIn()` in a handler or a template. The object stays the same
+ * for the component's life and always calls the capability of the document in
+ * scope, so it is safe to keep in a closure. A read (`stage.getZoomLevel()`)
+ * in a template or a computed updates when its answer changes.
+ *
+ * Outside a document (none open, not ready yet, or none in scope), a document
+ * plugin's members belong to its stand-in: reading one never throws, so chrome
+ * renders before the first document opens, and calling one refuses with
+ * `PluginError('not-ready')`: a method that returns a promise rejects, the
+ * others throw.
+ */
+export declare function useCapability<Capability>(token: MaybeRefOrGetter<CapabilityToken<Capability>>): Capability;
+/**
+ * A value read from a capability, as a ref. Strict: while the token can't
+ * resolve, reading it throws the kernel's reason (`no document`, `document is
+ * loading`), for code that knows a document exists, such as anything inside a
+ * `<DocumentGate>`. {@link useOptionalSelector} is its total twin.
+ */
+export declare function useSelector<Capability, Value>(token: MaybeRefOrGetter<CapabilityToken<Capability>>, select: (capability: Capability) => Value, isEqual?: (left: Value, right: Value) => boolean): Readonly<Ref<Value>>;
+/**
+ * Null-safe {@link useSelector}: `fallback` whenever the token can't resolve
+ * (no provider, or a document-scoped token with no document). For chrome that
+ * stays mounted across the empty workspace (a zoom readout, a mode band). A
+ * read through a capability whose document closed a moment ago is `fallback`
+ * too.
+ */
+export declare function useOptionalSelector<Capability, Value>(token: MaybeRefOrGetter<CapabilityToken<Capability>>, select: (capability: Capability) => Value, fallback: Value, isEqual?: (left: Value, right: Value) => boolean): Readonly<Ref<Value>>;
+/**
+ * Subscribe to a capability's {@link EventHook} while the component lives:
+ * `useCapabilityEvent(ActionsToken, (actions) => actions.onExecuted, handler)`.
+ * Events carry occurrences, never state (a late subscriber that needs the
+ * current value uses a selector). It subscribes to the document in scope, again
+ * when that document changes, and ends with the component. Null-safe: with no
+ * plugin or no document there is no subscription.
+ */
+export declare function useCapabilityEvent<Capability, Event>(token: MaybeRefOrGetter<CapabilityToken<Capability>>, select: (capability: Capability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/runtime/documents.d.cts

@@ -0,0 +1,42 @@
+import type { DocumentsCapability, EventHook, PageInfo, ViewerSettings } from '@embedpdf/core';
+import type { Ref } from 'vue';
+import type { FieldRefs } from './refs.cjs';
+/**
+ * The documents API: open, close, unlock, download, and the tabs. Inside a
+ * `<DocumentScope>`, the calls that leave out the document use that one, so
+ * `download()` without an id downloads the document in scope. The object never
+ * changes, so it's safe to keep in a closure. What to show comes from
+ * `useDocument()` and `useDocumentsState()`.
+ */
+export declare function useDocuments(): DocumentsCapability;
+/**
+ * The document this component talks to: the one its `<DocumentScope>` names,
+ * or else the active one. Its `id`, `name`, `status`, `pageCount`,
+ * `hasUnsavedChanges`, and why it's locked or failed, as refs. With no
+ * document, an empty one that reads as still opening. With a selector, one ref
+ * for the value it picks.
+ */
+export declare const useDocument: import("../index.cjs").StateComposable<import("@embedpdf/core").DocumentInfo>;
+/**
+ * Every open document, in tab order (loading, locked and failed ones too), and
+ * the active one's id, as refs. With a selector, one ref for the value it picks.
+ */
+export declare const useDocumentsState: import("../index.cjs").StateComposable<import("@embedpdf/core").DocumentsState>;
+/** Subscribe to one documents event while the component lives: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+export declare function useDocumentsEvent<Event>(select: (documents: DocumentsCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The pages of the document this component talks to, in order: each with its
+ * `ref`, `index`, `label`, size and rotation. Needs no Stage, so a thumbnail
+ * list or a page picker works anywhere. The same array until a page is added,
+ * removed, moved or rotated; empty with no document.
+ */
+export declare function usePageList(): Readonly<Ref<readonly PageInfo[]>>;
+/**
+ * The viewer's own settings (`<Viewer :identity :scope :accent :page>`), as
+ * refs, or one ref for the value `select` picks: the accent every part without
+ * a color of its own follows, and how pages look. What paints a page or an
+ * accent reads it here, through `paint()` from `@embedpdf/web`, so a CSS
+ * variable still wins.
+ */
+export declare function useViewerSettings(): FieldRefs<ViewerSettings>;
+export declare function useViewerSettings<Selected>(select: (settings: ViewerSettings) => Selected): Readonly<Ref<Selected>>;

package/dist/runtime/documents.d.ts

@@ -0,0 +1,42 @@
+import type { DocumentsCapability, EventHook, PageInfo, ViewerSettings } from '@embedpdf/core';
+import type { Ref } from 'vue';
+import type { FieldRefs } from './refs.js';
+/**
+ * The documents API: open, close, unlock, download, and the tabs. Inside a
+ * `<DocumentScope>`, the calls that leave out the document use that one, so
+ * `download()` without an id downloads the document in scope. The object never
+ * changes, so it's safe to keep in a closure. What to show comes from
+ * `useDocument()` and `useDocumentsState()`.
+ */
+export declare function useDocuments(): DocumentsCapability;
+/**
+ * The document this component talks to: the one its `<DocumentScope>` names,
+ * or else the active one. Its `id`, `name`, `status`, `pageCount`,
+ * `hasUnsavedChanges`, and why it's locked or failed, as refs. With no
+ * document, an empty one that reads as still opening. With a selector, one ref
+ * for the value it picks.
+ */
+export declare const useDocument: import("../index.js").StateComposable<import("@embedpdf/core").DocumentInfo>;
+/**
+ * Every open document, in tab order (loading, locked and failed ones too), and
+ * the active one's id, as refs. With a selector, one ref for the value it picks.
+ */
+export declare const useDocumentsState: import("../index.js").StateComposable<import("@embedpdf/core").DocumentsState>;
+/** Subscribe to one documents event while the component lives: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+export declare function useDocumentsEvent<Event>(select: (documents: DocumentsCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The pages of the document this component talks to, in order: each with its
+ * `ref`, `index`, `label`, size and rotation. Needs no Stage, so a thumbnail
+ * list or a page picker works anywhere. The same array until a page is added,
+ * removed, moved or rotated; empty with no document.
+ */
+export declare function usePageList(): Readonly<Ref<readonly PageInfo[]>>;
+/**
+ * The viewer's own settings (`<Viewer :identity :scope :accent :page>`), as
+ * refs, or one ref for the value `select` picks: the accent every part without
+ * a color of its own follows, and how pages look. What paints a page or an
+ * accent reads it here, through `paint()` from `@embedpdf/web`, so a CSS
+ * variable still wins.
+ */
+export declare function useViewerSettings(): FieldRefs<ViewerSettings>;
+export declare function useViewerSettings<Selected>(select: (settings: ViewerSettings) => Selected): Readonly<Ref<Selected>>;

package/dist/runtime/kernel.d.cts

@@ -0,0 +1,36 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { Kernel } from '@embedpdf/core';
+/** What `<Viewer>` gives the components inside it. */
+export interface ViewerBinding {
+    /** The kernel, from the moment `<Viewer>` creates it; null before that. */
+    readonly kernel: Kernel | null;
+    /** Read inside a computed: the computed runs again on every change the kernel announces. */
+    track(): void;
+}
+/** Installed by `<Viewer>`, not by app code. */
+export declare function provideViewer(binding: ViewerBinding): void;
+/** The binding of the nearest `<Viewer>`, with its kernel. */
+export declare function useViewerBinding(): ViewerBinding & {
+    readonly kernel: Kernel;
+};
+/** The kernel of the nearest `<Viewer>`. */
+export declare function useKernel(): Kernel;
+/**
+ * A value derived from the kernel, as a ref. `select` runs again on every
+ * kernel change and on a change to any ref it reads; the ref keeps its value
+ * while `isEqual` says the new one is the same, so nothing that reads it
+ * updates.
+ */
+export declare function useKernelValue<Value>(select: (kernel: Kernel) => Value, isEqual?: (left: Value, right: Value) => boolean): Readonly<Ref<Value>>;
+/** Installed by `<DocumentScope>`: the document the subtree talks to. */
+export declare function provideDocumentScope(id: MaybeRefOrGetter<string | null>): void;
+/**
+ * The document the nearest `<DocumentScope>` binds this subtree to, or null
+ * when it follows the active document. For readers that pass it to
+ * `kernel.tryCapability`; UI that needs the id itself uses {@link useDocumentId}.
+ */
+export declare function useDocumentScope(): Readonly<Ref<string | null>>;
+/** The active document's id, or null with none open. */
+export declare function useActiveDocumentId(): Readonly<Ref<string | null>>;
+/** The document id for this subtree: the nearest `<DocumentScope>`, else the active document. */
+export declare function useDocumentId(): Readonly<Ref<string | null>>;

package/dist/runtime/kernel.d.ts

@@ -0,0 +1,36 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { Kernel } from '@embedpdf/core';
+/** What `<Viewer>` gives the components inside it. */
+export interface ViewerBinding {
+    /** The kernel, from the moment `<Viewer>` creates it; null before that. */
+    readonly kernel: Kernel | null;
+    /** Read inside a computed: the computed runs again on every change the kernel announces. */
+    track(): void;
+}
+/** Installed by `<Viewer>`, not by app code. */
+export declare function provideViewer(binding: ViewerBinding): void;
+/** The binding of the nearest `<Viewer>`, with its kernel. */
+export declare function useViewerBinding(): ViewerBinding & {
+    readonly kernel: Kernel;
+};
+/** The kernel of the nearest `<Viewer>`. */
+export declare function useKernel(): Kernel;
+/**
+ * A value derived from the kernel, as a ref. `select` runs again on every
+ * kernel change and on a change to any ref it reads; the ref keeps its value
+ * while `isEqual` says the new one is the same, so nothing that reads it
+ * updates.
+ */
+export declare function useKernelValue<Value>(select: (kernel: Kernel) => Value, isEqual?: (left: Value, right: Value) => boolean): Readonly<Ref<Value>>;
+/** Installed by `<DocumentScope>`: the document the subtree talks to. */
+export declare function provideDocumentScope(id: MaybeRefOrGetter<string | null>): void;
+/**
+ * The document the nearest `<DocumentScope>` binds this subtree to, or null
+ * when it follows the active document. For readers that pass it to
+ * `kernel.tryCapability`; UI that needs the id itself uses {@link useDocumentId}.
+ */
+export declare function useDocumentScope(): Readonly<Ref<string | null>>;
+/** The active document's id, or null with none open. */
+export declare function useActiveDocumentId(): Readonly<Ref<string | null>>;
+/** The document id for this subtree: the nearest `<DocumentScope>`, else the active document. */
+export declare function useDocumentId(): Readonly<Ref<string | null>>;

package/dist/runtime/page.d.cts

@@ -0,0 +1,15 @@
+import type { Ref } from 'vue';
+import type { PageTransform } from '@embedpdf/core-geometry';
+import type { PageViewDemand } from '@embedpdf/plugin-render/contract';
+import type { PageContext } from '@embedpdf/web';
+export { makePageContext } from '@embedpdf/web';
+/** The page context. Its members are documented on `PageContext` in `@embedpdf/web`. */
+export type PageContextValue = PageContext<PageTransform, PageViewDemand>;
+/** Installed by page surfaces (`<Stage>` pages), not by app code. */
+export declare function providePage(page: Readonly<Ref<PageContextValue>>): void;
+/**
+ * The page this component is drawn on, as a ref: inside a `<Stage>`'s
+ * `#page` or `#page-chrome` slot. The ref is the same for the page's life;
+ * its value changes when the page's geometry does (a zoom, a rotation).
+ */
+export declare function usePage(): Readonly<Ref<PageContextValue>>;

package/dist/runtime/page.d.ts

@@ -0,0 +1,15 @@
+import type { Ref } from 'vue';
+import type { PageTransform } from '@embedpdf/core-geometry';
+import type { PageViewDemand } from '@embedpdf/plugin-render/contract';
+import type { PageContext } from '@embedpdf/web';
+export { makePageContext } from '@embedpdf/web';
+/** The page context. Its members are documented on `PageContext` in `@embedpdf/web`. */
+export type PageContextValue = PageContext<PageTransform, PageViewDemand>;
+/** Installed by page surfaces (`<Stage>` pages), not by app code. */
+export declare function providePage(page: Readonly<Ref<PageContextValue>>): void;
+/**
+ * The page this component is drawn on, as a ref: inside a `<Stage>`'s
+ * `#page` or `#page-chrome` slot. The ref is the same for the page's life;
+ * its value changes when the page's geometry does (a zoom, a rotation).
+ */
+export declare function usePage(): Readonly<Ref<PageContextValue>>;

package/dist/runtime/refs.d.cts

@@ -0,0 +1,12 @@
+import type { Ref } from 'vue';
+/** One read-only ref per field of `Value`. */
+export type FieldRefs<Value extends object> = {
+    readonly [Key in keyof Value]-?: Readonly<Ref<Value[Key]>>;
+};
+/**
+ * One computed ref per field of `whole`. Each field updates only when its own
+ * value changes. The fields are the ones `whole` has now (`keys` names them
+ * when they are known without a value): records read this way keep their
+ * fields.
+ */
+export declare function fieldRefs<Value extends object>(whole: Readonly<Ref<Value>>, keys?: readonly string[]): FieldRefs<Value>;

package/dist/runtime/refs.d.ts

@@ -0,0 +1,12 @@
+import type { Ref } from 'vue';
+/** One read-only ref per field of `Value`. */
+export type FieldRefs<Value extends object> = {
+    readonly [Key in keyof Value]-?: Readonly<Ref<Value[Key]>>;
+};
+/**
+ * One computed ref per field of `whole`. Each field updates only when its own
+ * value changes. The fields are the ones `whole` has now (`keys` names them
+ * when they are known without a value): records read this way keep their
+ * fields.
+ */
+export declare function fieldRefs<Value extends object>(whole: Readonly<Ref<Value>>, keys?: readonly string[]): FieldRefs<Value>;

package/dist/runtime/surface-box.d.cts

@@ -0,0 +1,12 @@
+/**
+ * A page surface's boxes (`pageSurfaceLayout` from `@embedpdf/web`) as Vue style values, for
+ * the Stage's pages and `<PageView>`: Vue adds no unit to a number, so each is in pixels here.
+ */
+import type { SurfaceBox } from '@embedpdf/web';
+/** `left`, `top`, `width` and `height` in pixels. */
+export declare function pixelBox(box: SurfaceBox): {
+    left: string;
+    top: string;
+    width: string;
+    height: string;
+};

package/dist/runtime/surface-box.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A page surface's boxes (`pageSurfaceLayout` from `@embedpdf/web`) as Vue style values, for
+ * the Stage's pages and `<PageView>`: Vue adds no unit to a number, so each is in pixels here.
+ */
+import type { SurfaceBox } from '@embedpdf/web';
+/** `left`, `top`, `width` and `height` in pixels. */
+export declare function pixelBox(box: SurfaceBox): {
+    left: string;
+    top: string;
+    width: string;
+    height: string;
+};

package/dist/runtime.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@embedpdf/core");
+const web = require("@embedpdf/web");
+const DocumentScope_vue_vue_type_script_setup_true_lang = require("./DocumentScope.vue_vue_type_script_setup_true_lang-loLSm4lV.cjs");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const documents = require("./documents-TQ1fMdWI.cjs");
+const page = require("./page-Doy4_Sdz.cjs");
+const state = require("./state-M22NDJQo.cjs");
+Object.defineProperty(exports, "makePageContext", {
+  enumerable: true,
+  get: () => web.makePageContext
+});
+Object.defineProperty(exports, "mountWebFont", {
+  enumerable: true,
+  get: () => web.mountWebFont
+});
+Object.defineProperty(exports, "saveFile", {
+  enumerable: true,
+  get: () => web.saveFile
+});
+exports.DocumentGate = DocumentScope_vue_vue_type_script_setup_true_lang._sfc_main;
+exports.DocumentScope = DocumentScope_vue_vue_type_script_setup_true_lang._sfc_main$1;
+exports.KernelProvider = DocumentScope_vue_vue_type_script_setup_true_lang._sfc_main$2;
+exports.Viewer = DocumentScope_vue_vue_type_script_setup_true_lang._sfc_main$3;
+exports.epdfTheme = DocumentScope_vue_vue_type_script_setup_true_lang.epdfTheme;
+exports.useActiveDocumentId = capabilities.useActiveDocumentId;
+exports.useCapability = capabilities.useCapability;
+exports.useCapabilityEvent = capabilities.useCapabilityEvent;
+exports.useCapabilityRef = capabilities.useCapabilityRef;
+exports.useDocumentId = capabilities.useDocumentId;
+exports.useDocumentScope = capabilities.useDocumentScope;
+exports.useKernel = capabilities.useKernel;
+exports.useKernelValue = capabilities.useKernelValue;
+exports.useOptionalCapability = capabilities.useOptionalCapability;
+exports.useOptionalSelector = capabilities.useOptionalSelector;
+exports.useSelector = capabilities.useSelector;
+exports.useDocument = documents.useDocument;
+exports.useDocuments = documents.useDocuments;
+exports.useDocumentsEvent = documents.useDocumentsEvent;
+exports.useDocumentsState = documents.useDocumentsState;
+exports.usePageList = documents.usePageList;
+exports.useViewerSettings = documents.useViewerSettings;
+exports.providePage = page.providePage;
+exports.usePage = page.usePage;
+exports.fieldRefs = state.fieldRefs;
+Object.keys(core).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => core[k]
+  });
+});
+//# sourceMappingURL=runtime.cjs.map

package/dist/runtime.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/runtime.d.cts

@@ -0,0 +1,24 @@
+/**
+ * @embedpdf/vue/runtime: the generic binding.
+ *
+ * `<Viewer>` owns the kernel and binds its one change stream to Vue; the
+ * composables resolve capabilities (document-scoped ones against the active
+ * or `<DocumentScope>`-given document, with a stand-in while there is none) and
+ * read state as refs; the page context is the seam every layer draws through.
+ * Every plugin binding rides on this.
+ */
+export * from '@embedpdf/core';
+export { mountWebFont, saveFile } from '@embedpdf/web';
+export { epdfTheme } from './theme.cjs';
+export type { EpdfTheme } from './theme.cjs';
+export { default as Viewer } from './runtime/Viewer.vue.cjs';
+export { default as KernelProvider } from './runtime/KernelProvider.vue.cjs';
+export { default as DocumentGate } from './runtime/DocumentGate.vue.cjs';
+export { default as DocumentScope } from './runtime/DocumentScope.vue.cjs';
+export { useActiveDocumentId, useDocumentId, useDocumentScope, useKernel, useKernelValue, } from './runtime/kernel.cjs';
+export { useCapability, useCapabilityEvent, useCapabilityRef, useOptionalCapability, useOptionalSelector, useSelector, } from './runtime/capabilities.cjs';
+export { useDocument, useDocuments, useDocumentsEvent, useDocumentsState, usePageList, useViewerSettings, } from './runtime/documents.cjs';
+export { makePageContext, providePage, usePage } from './runtime/page.cjs';
+export type { PageContextValue } from './runtime/page.cjs';
+export { fieldRefs } from './runtime/refs.cjs';
+export type { FieldRefs } from './runtime/refs.cjs';

package/dist/runtime.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @embedpdf/vue/runtime: the generic binding.
+ *
+ * `<Viewer>` owns the kernel and binds its one change stream to Vue; the
+ * composables resolve capabilities (document-scoped ones against the active
+ * or `<DocumentScope>`-given document, with a stand-in while there is none) and
+ * read state as refs; the page context is the seam every layer draws through.
+ * Every plugin binding rides on this.
+ */
+export * from '@embedpdf/core';
+export { mountWebFont, saveFile } from '@embedpdf/web';
+export { epdfTheme } from './theme.js';
+export type { EpdfTheme } from './theme.js';
+export { default as Viewer } from './runtime/Viewer.vue.js';
+export { default as KernelProvider } from './runtime/KernelProvider.vue.js';
+export { default as DocumentGate } from './runtime/DocumentGate.vue.js';
+export { default as DocumentScope } from './runtime/DocumentScope.vue.js';
+export { useActiveDocumentId, useDocumentId, useDocumentScope, useKernel, useKernelValue, } from './runtime/kernel.js';
+export { useCapability, useCapabilityEvent, useCapabilityRef, useOptionalCapability, useOptionalSelector, useSelector, } from './runtime/capabilities.js';
+export { useDocument, useDocuments, useDocumentsEvent, useDocumentsState, usePageList, useViewerSettings, } from './runtime/documents.js';
+export { makePageContext, providePage, usePage } from './runtime/page.js';
+export type { PageContextValue } from './runtime/page.js';
+export { fieldRefs } from './runtime/refs.js';
+export type { FieldRefs } from './runtime/refs.js';

package/dist/runtime.js

@@ -0,0 +1,38 @@
+export * from "@embedpdf/core";
+import { makePageContext, mountWebFont, saveFile } from "@embedpdf/web";
+import { _, a, b, c, e } from "./DocumentScope.vue_vue_type_script_setup_true_lang-CtTu1FGX.js";
+import { u, a as a2, b as b2, c as c2, d, e as e2, f, g, h, i, j } from "./capabilities-C7YzgPCX.js";
+import { u as u2, a as a3, b as b3, c as c3, d as d2, e as e3 } from "./documents-DUu5H4yH.js";
+import { p, u as u3 } from "./page-D9XIuLSj.js";
+import { f as f2 } from "./state-DZg8q3v6.js";
+export {
+  _ as DocumentGate,
+  a as DocumentScope,
+  b as KernelProvider,
+  c as Viewer,
+  e as epdfTheme,
+  f2 as fieldRefs,
+  makePageContext,
+  mountWebFont,
+  p as providePage,
+  saveFile,
+  u as useActiveDocumentId,
+  a2 as useCapability,
+  b2 as useCapabilityEvent,
+  c2 as useCapabilityRef,
+  u2 as useDocument,
+  d as useDocumentId,
+  e2 as useDocumentScope,
+  a3 as useDocuments,
+  b3 as useDocumentsEvent,
+  c3 as useDocumentsState,
+  f as useKernel,
+  g as useKernelValue,
+  h as useOptionalCapability,
+  i as useOptionalSelector,
+  u3 as usePage,
+  d2 as usePageList,
+  j as useSelector,
+  e3 as useViewerSettings
+};
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/scope-BQA4toWB.cjs

@@ -0,0 +1,17 @@
+"use strict";
+const vue = require("vue");
+const contract = require("@embedpdf/plugin-stage/contract");
+const StageTokenKey = Symbol("embedpdf stage token");
+function provideStageToken(token) {
+  vue.provide(
+    StageTokenKey,
+    vue.computed(() => vue.toValue(token))
+  );
+}
+function useStageToken(explicit) {
+  const scoped = vue.inject(StageTokenKey, null);
+  return vue.computed(() => vue.toValue(explicit) ?? (scoped == null ? void 0 : scoped.value) ?? contract.StageToken);
+}
+exports.provideStageToken = provideStageToken;
+exports.useStageToken = useStageToken;
+//# sourceMappingURL=scope-BQA4toWB.cjs.map

package/dist/scope-BQA4toWB.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-BQA4toWB.cjs","sources":["../src/stage/scope.ts"],"sourcesContent":["/**\n * Which stage lens a subtree binds to, so the stage composables and the\n * stage-bound chrome (`<Scrollbar>`, selection handles) need no token argument.\n * `<Stage>` provides its own lens to its pages and overlay; an app wraps a\n * second lens (a thumbnail rail) in `<StageScope :token>`. An explicit token\n * argument still wins everywhere.\n */\nimport { computed, inject, provide, toValue } from 'vue';\nimport type { InjectionKey, MaybeRefOrGetter, Ref } from 'vue';\nimport type { CapabilityToken } from '@embedpdf/core';\nimport { StageToken } from '@embedpdf/plugin-stage/contract';\nimport type { StageCapability } from '@embedpdf/plugin-stage/contract';\n\n/** Which stage lens to bind to: the main `StageToken`, or the token of a second view. */\nexport type StageTokenProp = CapabilityToken<StageCapability>;\n\nconst StageTokenKey: InjectionKey<Readonly<Ref<StageTokenProp>>> = Symbol('embedpdf stage token');\n\n/** Bind this subtree to a stage lens: what `<Stage>` and `<StageScope>` do. */\nexport function provideStageToken(token: MaybeRefOrGetter<StageTokenProp>): void {\n  provide(\n    StageTokenKey,\n    computed(() => toValue(token)),\n  );\n}\n\n/**\n * The lens a stage composable binds to: the explicit argument, else the\n * nearest `<StageScope>` / `<Stage>`, else the main lens.\n */\nexport function useStageToken(\n  explicit?: MaybeRefOrGetter<StageTokenProp | undefined>,\n): Readonly<Ref<StageTokenProp>> {\n  const scoped = inject(StageTokenKey, null);\n  return computed(() => toValue(explicit) ?? scoped?.value ?? StageToken);\n}\n"],"names":["provide","computed","toValue","inject","StageToken"],"mappings":";;;AAgBA,MAAM,gBAA6D,OAAO,sBAAsB;AAGzF,SAAS,kBAAkB,OAA+C;AAC/EA,MAAAA;AAAAA,IACE;AAAA,IACAC,aAAS,MAAMC,IAAAA,QAAQ,KAAK,CAAC;AAAA,EAAA;AAEjC;AAMO,SAAS,cACd,UAC+B;AAC/B,QAAM,SAASC,IAAAA,OAAO,eAAe,IAAI;AACzC,SAAOF,IAAAA,SAAS,MAAMC,YAAQ,QAAQ,MAAK,iCAAQ,UAASE,mBAAU;AACxE;;;"}

package/dist/scope-BgdCqnYb.js

@@ -0,0 +1,18 @@
+import { inject, computed, toValue, provide } from "vue";
+import { StageToken } from "@embedpdf/plugin-stage/contract";
+const StageTokenKey = Symbol("embedpdf stage token");
+function provideStageToken(token) {
+  provide(
+    StageTokenKey,
+    computed(() => toValue(token))
+  );
+}
+function useStageToken(explicit) {
+  const scoped = inject(StageTokenKey, null);
+  return computed(() => toValue(explicit) ?? (scoped == null ? void 0 : scoped.value) ?? StageToken);
+}
+export {
+  provideStageToken as p,
+  useStageToken as u
+};
+//# sourceMappingURL=scope-BgdCqnYb.js.map

package/dist/scope-BgdCqnYb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-BgdCqnYb.js","sources":["../src/stage/scope.ts"],"sourcesContent":["/**\n * Which stage lens a subtree binds to, so the stage composables and the\n * stage-bound chrome (`<Scrollbar>`, selection handles) need no token argument.\n * `<Stage>` provides its own lens to its pages and overlay; an app wraps a\n * second lens (a thumbnail rail) in `<StageScope :token>`. An explicit token\n * argument still wins everywhere.\n */\nimport { computed, inject, provide, toValue } from 'vue';\nimport type { InjectionKey, MaybeRefOrGetter, Ref } from 'vue';\nimport type { CapabilityToken } from '@embedpdf/core';\nimport { StageToken } from '@embedpdf/plugin-stage/contract';\nimport type { StageCapability } from '@embedpdf/plugin-stage/contract';\n\n/** Which stage lens to bind to: the main `StageToken`, or the token of a second view. */\nexport type StageTokenProp = CapabilityToken<StageCapability>;\n\nconst StageTokenKey: InjectionKey<Readonly<Ref<StageTokenProp>>> = Symbol('embedpdf stage token');\n\n/** Bind this subtree to a stage lens: what `<Stage>` and `<StageScope>` do. */\nexport function provideStageToken(token: MaybeRefOrGetter<StageTokenProp>): void {\n  provide(\n    StageTokenKey,\n    computed(() => toValue(token)),\n  );\n}\n\n/**\n * The lens a stage composable binds to: the explicit argument, else the\n * nearest `<StageScope>` / `<Stage>`, else the main lens.\n */\nexport function useStageToken(\n  explicit?: MaybeRefOrGetter<StageTokenProp | undefined>,\n): Readonly<Ref<StageTokenProp>> {\n  const scoped = inject(StageTokenKey, null);\n  return computed(() => toValue(explicit) ?? scoped?.value ?? StageToken);\n}\n"],"names":[],"mappings":";;AAgBA,MAAM,gBAA6D,OAAO,sBAAsB;AAGzF,SAAS,kBAAkB,OAA+C;AAC/E;AAAA,IACE;AAAA,IACA,SAAS,MAAM,QAAQ,KAAK,CAAC;AAAA,EAAA;AAEjC;AAMO,SAAS,cACd,UAC+B;AAC/B,QAAM,SAAS,OAAO,eAAe,IAAI;AACzC,SAAO,SAAS,MAAM,QAAQ,QAAQ,MAAK,iCAAQ,UAAS,UAAU;AACxE;"}

package/dist/search/SearchLayer.vue.d.cts

@@ -0,0 +1,17 @@
+import type { SearchHit } from '@embedpdf/plugin-search';
+type __VLS_Props = {
+    /**
+     * `@hit-click`: makes the matches clickable, and is called with the match
+     * someone clicks, for example to make it the active one with
+     * `search.goToHit(hit)`. The press still reaches the page, so a drag that
+     * starts on a match selects text, and only a click calls it. Without it,
+     * matches are only paint and the pointer goes straight through.
+     *
+     * A prop rather than an emitted event, so the layer knows whether you
+     * listen: only then do the matches take the pointer.
+     */
+    onHitClick?: (hit: SearchHit) => void;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/search/SearchLayer.vue.d.ts

@@ -0,0 +1,17 @@
+import type { SearchHit } from '@embedpdf/plugin-search';
+type __VLS_Props = {
+    /**
+     * `@hit-click`: makes the matches clickable, and is called with the match
+     * someone clicks, for example to make it the active one with
+     * `search.goToHit(hit)`. The press still reaches the page, so a drag that
+     * starts on a match selects text, and only a click calls it. Without it,
+     * matches are only paint and the pointer goes straight through.
+     *
+     * A prop rather than an emitted event, so the layer knows whether you
+     * listen: only then do the matches take the pointer.
+     */
+    onHitClick?: (hit: SearchHit) => void;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/search/composables.d.cts

@@ -0,0 +1,31 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { SearchCapability, SearchHit } from '@embedpdf/plugin-search';
+import type { EventHook, PageRef } from '@embedpdf/core';
+/** The search API (`search`, `clear`, `nextHit`, `goToHit`, …) for your chrome. The object never changes. */
+export declare function useSearch(): SearchCapability;
+/** Subscribe to one search event while the component lives: `useSearchEvent((search) => search.onCompleted, handler)`. */
+export declare function useSearchEvent<Event>(select: (search: SearchCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The search's state as refs: the query, status, count, active match, progress
+ * and error (the page's State table, declared once in `searchState`). With a
+ * selector, one ref that updates only when the value it picks changes.
+ */
+export declare const useSearchState: import("../index.cjs").StateComposable<{
+    query: import("@embedpdf/plugin-search").SearchQuery | null;
+    status: import("@embedpdf/plugin-search").SearchStatus;
+    hitCount: number;
+    activeHitIndex: number;
+    activeHit: SearchHit | null;
+    progress: import("@embedpdf/plugin-search").SearchProgress;
+    error: import("@embedpdf/core").PluginErrorInfo | null;
+}>;
+/** The search settings (`reveal`, `highlight`), with or without a document, as refs. Takes a selector. */
+export declare const useSearchSettings: import("../index.cjs").SettingsComposable<import("@embedpdf/plugin-search").SearchSettings & object>;
+/**
+ * Every match found so far, or one page's (its ref or index; a getter to
+ * follow a prop), as a ref: for a results list or a count per thumbnail. The
+ * plugin hands out the same array until matches land on what it covers, so
+ * the ref updates only then. Empty without a document, and for a page that
+ * isn't in the document.
+ */
+export declare function useSearchHits(page?: MaybeRefOrGetter<PageRef | number | undefined>): Readonly<Ref<readonly SearchHit[]>>;

package/dist/search/composables.d.ts

@@ -0,0 +1,31 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { SearchCapability, SearchHit } from '@embedpdf/plugin-search';
+import type { EventHook, PageRef } from '@embedpdf/core';
+/** The search API (`search`, `clear`, `nextHit`, `goToHit`, …) for your chrome. The object never changes. */
+export declare function useSearch(): SearchCapability;
+/** Subscribe to one search event while the component lives: `useSearchEvent((search) => search.onCompleted, handler)`. */
+export declare function useSearchEvent<Event>(select: (search: SearchCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The search's state as refs: the query, status, count, active match, progress
+ * and error (the page's State table, declared once in `searchState`). With a
+ * selector, one ref that updates only when the value it picks changes.
+ */
+export declare const useSearchState: import("../index.js").StateComposable<{
+    query: import("@embedpdf/plugin-search").SearchQuery | null;
+    status: import("@embedpdf/plugin-search").SearchStatus;
+    hitCount: number;
+    activeHitIndex: number;
+    activeHit: SearchHit | null;
+    progress: import("@embedpdf/plugin-search").SearchProgress;
+    error: import("@embedpdf/core").PluginErrorInfo | null;
+}>;
+/** The search settings (`reveal`, `highlight`), with or without a document, as refs. Takes a selector. */
+export declare const useSearchSettings: import("../index.js").SettingsComposable<import("@embedpdf/plugin-search").SearchSettings & object>;
+/**
+ * Every match found so far, or one page's (its ref or index; a getter to
+ * follow a prop), as a ref: for a results list or a count per thumbnail. The
+ * plugin hands out the same array until matches land on what it covers, so
+ * the ref updates only then. Empty without a document, and for a page that
+ * isn't in the document.
+ */
+export declare function useSearchHits(page?: MaybeRefOrGetter<PageRef | number | undefined>): Readonly<Ref<readonly SearchHit[]>>;

package/dist/search.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginSearch = require("@embedpdf/plugin-search");
+const SearchLayer_vue_vue_type_script_setup_true_lang = require("./SearchLayer.vue_vue_type_script_setup_true_lang-CQozZCvB.cjs");
+exports.SearchLayer = SearchLayer_vue_vue_type_script_setup_true_lang._sfc_main;
+exports.useSearch = SearchLayer_vue_vue_type_script_setup_true_lang.useSearch;
+exports.useSearchEvent = SearchLayer_vue_vue_type_script_setup_true_lang.useSearchEvent;
+exports.useSearchHits = SearchLayer_vue_vue_type_script_setup_true_lang.useSearchHits;
+exports.useSearchSettings = SearchLayer_vue_vue_type_script_setup_true_lang.useSearchSettings;
+exports.useSearchState = SearchLayer_vue_vue_type_script_setup_true_lang.useSearchState;
+Object.keys(pluginSearch).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginSearch[k]
+  });
+});
+//# sourceMappingURL=search.cjs.map

package/dist/search.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}