@embedpdf/svelte 0.0.0-stage → 3.0.0-next.16

package/dist/runtime/page-layers.svelte.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The Svelte side of `@embedpdf/web`'s page layers: a layer says, for as long as it lives, which
+ * part of its page it paints, and the render layer reads which parts are painted, to leave them
+ * out of the page's picture.
+ */
+import { type PagePart, type PaintedParts } from '@embedpdf/web';
+/**
+ * Say, for as long as this component lives, that it paints `part` of its page (`pageRef()`, the
+ * page context's `ref`; `null` while it paints nothing). Said as the component starts, so a render
+ * layer started alongside knows it by the time it's mounted.
+ */
+export declare function usePaintsPagePart(pageRef: () => object | null, part: PagePart): void;
+/**
+ * Which parts of the page (`pageRef()`, the page context's `ref`) the layers on it paint: `null`
+ * until this component is mounted, when every layer started with it has said what it paints, so
+ * the page's picture is never asked for with a part another layer is about to take.
+ */
+export declare function usePaintedParts(pageRef: () => object): {
+    readonly current: PaintedParts | null;
+};

package/dist/runtime/page-layers.svelte.js

@@ -0,0 +1,40 @@
+/**
+ * The Svelte side of `@embedpdf/web`'s page layers: a layer says, for as long as it lives, which
+ * part of its page it paints, and the render layer reads which parts are painted, to leave them
+ * out of the page's picture.
+ */
+import { pageLayersOf } from '@embedpdf/web';
+import { untrack } from 'svelte';
+/**
+ * Say, for as long as this component lives, that it paints `part` of its page (`pageRef()`, the
+ * page context's `ref`; `null` while it paints nothing). Said as the component starts, so a render
+ * layer started alongside knows it by the time it's mounted.
+ */
+export function usePaintsPagePart(pageRef, part) {
+    $effect.pre(() => {
+        const ref = pageRef();
+        if (!ref)
+            return;
+        return untrack(() => pageLayersOf(ref).paint(part));
+    });
+}
+/**
+ * Which parts of the page (`pageRef()`, the page context's `ref`) the layers on it paint: `null`
+ * until this component is mounted, when every layer started with it has said what it paints, so
+ * the page's picture is never asked for with a part another layer is about to take.
+ */
+export function usePaintedParts(pageRef) {
+    let painted = $state.raw(null);
+    $effect(() => {
+        const layers = pageLayersOf(pageRef());
+        return untrack(() => {
+            painted = layers.painted();
+            return layers.subscribe(() => (painted = layers.painted()));
+        });
+    });
+    return {
+        get current() {
+            return painted;
+        },
+    };
+}

package/dist/runtime/page.d.ts

@@ -0,0 +1,10 @@
+import type { PageTransform } from '@embedpdf/core-geometry';
+import type { PageViewDemand } from '@embedpdf/plugin-render/contract';
+import type { PageContext } from '@embedpdf/web';
+export { livePageContext, makePageContext } from '@embedpdf/web';
+/** The page context. Its members are documented on `PageContext` in `@embedpdf/web`. */
+export type PageContextValue = PageContext<PageTransform, PageViewDemand>;
+/** For page surfaces (`<Stage>`'s pages, `<PageView>`): provide the page to everything inside. */
+export declare function setPageContext(page: PageContextValue): void;
+/** The page this layer draws on. Throws outside a page surface. */
+export declare function usePage(): PageContextValue;

package/dist/runtime/page.js

@@ -0,0 +1,23 @@
+/**
+ * The page context: what a layer knows about the page it draws on. A layer depends only on this,
+ * never on the Stage, so the same layer works on a Stage page and on a single `<PageView>`.
+ *
+ * A page surface provides it as a function that returns the current value; `usePage()` gives a
+ * layer an object that reads through that function on every access, so `page.transform` in a
+ * template or a `$derived` follows the zoom.
+ */
+import { getContext, hasContext, setContext } from 'svelte';
+// Built by `makePageContext`, and kept current by `livePageContext`, from `@embedpdf/web`.
+export { livePageContext, makePageContext } from '@embedpdf/web';
+const PAGE = Symbol('embedpdf.page');
+/** For page surfaces (`<Stage>`'s pages, `<PageView>`): provide the page to everything inside. */
+export function setPageContext(page) {
+    setContext(PAGE, page);
+}
+/** The page this layer draws on. Throws outside a page surface. */
+export function usePage() {
+    if (!hasContext(PAGE)) {
+        throw new Error('[embedpdf] usePage() must be used inside <PageView> or a <Stage> page.');
+    }
+    return getContext(PAGE);
+}

package/dist/runtime/props.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The props of the runtime's components: `<Viewer>`, `<KernelProvider>`, `<DocumentGate>` and
+ * `<DocumentScope>`.
+ */
+import type { Snippet } from 'svelte';
+import type { AnyPlugin, Engine, EngineFactory, FailedDocumentInfo, Identity, InitialDocument, Kernel, LockedDocumentInfo, ViewerPageSettings } from '@embedpdf/core';
+export interface ViewerProps {
+    /**
+     * The engine, as an instance or a function. An instance (`{engine}`) is borrowed: the viewer
+     * uses it and never destroys it, so one engine made at module scope serves every viewer; a
+     * local engine is warmed up on mount. A function (`engine={() => localEngine()}`) is the
+     * viewer's own: called on mount, destroyed on unmount. Read once, when the viewer mounts.
+     */
+    engine: Engine | EngineFactory;
+    /** The plugins. Read once, when the viewer mounts. */
+    plugins: AnyPlugin[];
+    /** Documents to open on startup, with optional tab names. Read once. */
+    initialDocuments?: InitialDocument[];
+    /**
+     * Called once the viewer has started, before the content mounts and before `initialDocuments`
+     * open: the door for code that isn't a component (register commands, subscribe to events).
+     */
+    onReady?: (kernel: Kernel) => void;
+    /**
+     * Who the user is, for every document opened without an `identity` of its own. Documents
+     * opened after a change use the new value; open ones keep theirs. The local engine only: the
+     * cloud engine reads it from the document's token.
+     */
+    identity?: Identity;
+    /**
+     * What the user may do, as permissions, in every document opened without a `scope` of its own.
+     * Left out, they may do everything. Changes reach the documents opened after them.
+     */
+    scope?: readonly string[];
+    /** The color every part without a color of its own follows. CSS `--epdf-accent` wins over it. */
+    accent?: string;
+    /** How pages look: `background` before the picture arrives, and the `shadow` under each page. */
+    page?: Partial<ViewerPageSettings>;
+    /** Shown while the viewer starts. */
+    fallback?: Snippet;
+    /** Shown when the viewer couldn't start, with why. Without it, a failed start shows nothing. */
+    error?: Snippet<[error: unknown]>;
+    children?: Snippet;
+}
+export interface KernelProviderProps {
+    /** The kernel everything inside reads. Read once: a new kernel takes a new provider. */
+    kernel: Kernel;
+    children?: Snippet;
+}
+export interface DocumentGateProps {
+    /** Shown while this subtree has no document: none is open, or it's still opening. */
+    fallback?: Snippet;
+    /** Shown while the document waits for its password; `fallback` without it. */
+    locked?: Snippet<[document: LockedDocumentInfo]>;
+    /** Shown when the document couldn't be opened, with why; `fallback` without it. */
+    error?: Snippet<[document: FailedDocumentInfo]>;
+    children?: Snippet;
+}
+export interface DocumentScopeProps {
+    /** The document everything inside talks to. */
+    id: string;
+    children?: Snippet;
+}

package/dist/runtime/props.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/readers.svelte.d.ts

@@ -0,0 +1,47 @@
+import type { CapabilityToken, EventHook, Kernel } from '@embedpdf/core';
+import { type CurrentValue, type MaybeGetter } from './values.svelte.js';
+/** Equal when the two arrays hold the same items in the same order. */
+export declare const shallowArray: <T>(left: readonly T[], right: readonly T[]) => boolean;
+/**
+ * A value derived from the kernel, computed again after every kernel change and passed on only
+ * when `isEqual` says it changed.
+ */
+export declare function useKernelValue<R>(select: (kernel: Kernel) => R, isEqual?: (left: R, right: R) => boolean): CurrentValue<R>;
+/** The active document's id, or null with none open. */
+export declare function useActiveDocumentId(): CurrentValue<string | null>;
+/** The document the nearest `<DocumentScope>` names, or null when this subtree follows the active one. */
+export declare function useDocumentScope(): CurrentValue<string | null>;
+/** The document this subtree talks to: the nearest `<DocumentScope>`'s, else the active one. */
+export declare function useDocumentId(): CurrentValue<string | null>;
+/**
+ * A plugin's capability, as a handle that is always the capability of the document in scope
+ * (see `./capability-handle.ts`). Outside a ready document a document plugin's calls refuse with
+ * `not-ready` (a method that returns a promise rejects), and its settings calls still work. A token no plugin provides throws now: a setup
+ * mistake. The token may be a function, for a component whose token is a prop.
+ */
+export declare function useCapability<T>(token: MaybeGetter<CapabilityToken<T>>): T;
+/**
+ * The capability itself, or null while the token can't resolve (no plugin, no document, or a
+ * document that isn't ready yet). The object is the plugin's own, so it can be handed to code
+ * that keeps it, such as an effect that registers something with it.
+ */
+export declare function useOptionalCapability<T>(token: MaybeGetter<CapabilityToken<T>>): CurrentValue<T | null>;
+/**
+ * A value selected from a capability. Strict: while the token can't resolve, reading it throws
+ * the kernel's reason (no document, the 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<C, R>(token: MaybeGetter<CapabilityToken<C>>, select: (capability: C) => R, isEqual?: (left: R, right: R) => boolean): CurrentValue<R>;
+/**
+ * A value selected from a capability, or `fallback` while the token can't resolve: for chrome
+ * that stays mounted while no document is open (a zoom readout). A read through a capability
+ * whose document closed a moment ago gives `fallback` too.
+ */
+export declare function useOptionalSelector<C, R>(token: MaybeGetter<CapabilityToken<C>>, select: (capability: C) => R, fallback: R, isEqual?: (left: R, right: R) => boolean): CurrentValue<R>;
+/**
+ * Subscribe to one of a capability's events while the component lives:
+ * `useCapabilityEvent(StageToken, (stage) => stage.onZoomChanged, handler)`. It subscribes again
+ * when the document in scope changes, and not at all without one. Events say what happened;
+ * the current value is a state reader's.
+ */
+export declare function useCapabilityEvent<C, T>(token: MaybeGetter<CapabilityToken<C>>, select: (capability: C) => EventHook<T>, handler: (event: T) => void): void;

package/dist/runtime/readers.svelte.js

@@ -0,0 +1,122 @@
+/**
+ * The generic readers every plugin binding is built from: a value derived from the kernel, a
+ * plugin's capability (as a handle, or the raw object), a value selected from it, and its events.
+ *
+ * Call them while a component is created, like every `use…()` function: they read the viewer and
+ * the document scope from context, and the event readers clean up when the component goes away.
+ */
+import { untrack } from 'svelte';
+import { standInFor } from '@embedpdf/core';
+import { documentScopeOf, useKernelBinding } from './binding.svelte.js';
+import { capabilityHandle } from './capability-handle.js';
+import { currentOf, derivedValue, valueOf, } from './values.svelte.js';
+/** Equal when the two arrays hold the same items in the same order. */
+export const shallowArray = (left, right) => left === right || (left.length === right.length && left.every((item, i) => item === right[i]));
+/**
+ * A value derived from the kernel, computed again after every kernel change and passed on only
+ * when `isEqual` says it changed.
+ */
+export function useKernelValue(select, isEqual = Object.is) {
+    const binding = useKernelBinding();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        return select(binding.kernel);
+    }, isEqual));
+}
+/** The active document's id, or null with none open. */
+export function useActiveDocumentId() {
+    return useKernelValue((kernel) => kernel.documents.getActiveId());
+}
+/** The document the nearest `<DocumentScope>` names, or null when this subtree follows the active one. */
+export function useDocumentScope() {
+    return currentOf(documentScopeOf());
+}
+/** The document this subtree talks to: the nearest `<DocumentScope>`'s, else the active one. */
+export function useDocumentId() {
+    const scoped = documentScopeOf();
+    return useKernelValue((kernel) => scoped() ?? kernel.documents.getActiveId());
+}
+/**
+ * A plugin's capability, as a handle that is always the capability of the document in scope
+ * (see `./capability-handle.ts`). Outside a ready document a document plugin's calls refuse with
+ * `not-ready` (a method that returns a promise rejects), and its settings calls still work. A token no plugin provides throws now: a setup
+ * mistake. The token may be a function, for a component whose token is a prop.
+ */
+export function useCapability(token) {
+    const binding = useKernelBinding();
+    const { kernel } = binding;
+    const scoped = documentScopeOf();
+    const initial = untrack(() => valueOf(token));
+    if (kernel.scopeOf(initial) !== 'document')
+        kernel.capability(initial);
+    return capabilityHandle(() => {
+        const current = valueOf(token);
+        return kernel.tryCapability(current, scoped() ?? undefined) ?? standInFor(kernel, current);
+    }, () => binding.track());
+}
+/**
+ * The capability itself, or null while the token can't resolve (no plugin, no document, or a
+ * document that isn't ready yet). The object is the plugin's own, so it can be handed to code
+ * that keeps it, such as an effect that registers something with it.
+ */
+export function useOptionalCapability(token) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        return binding.kernel.tryCapability(valueOf(token), scoped() ?? undefined);
+    }));
+}
+/**
+ * A value selected from a capability. Strict: while the token can't resolve, reading it throws
+ * the kernel's reason (no document, the document is loading), for code that knows a document
+ * exists, such as anything inside a `<DocumentGate>`. {@link useOptionalSelector} is its total twin.
+ */
+export function useSelector(token, select, isEqual = Object.is) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        const current = valueOf(token);
+        const documentId = scoped() ?? undefined;
+        const capability = binding.kernel.tryCapability(current, documentId) ??
+            binding.kernel.capability(current, documentId);
+        return select(capability);
+    }, isEqual));
+}
+/**
+ * A value selected from a capability, or `fallback` while the token can't resolve: for chrome
+ * that stays mounted while no document is open (a zoom readout). A read through a capability
+ * whose document closed a moment ago gives `fallback` too.
+ */
+export function useOptionalSelector(token, select, fallback, isEqual = Object.is) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    return currentOf(derivedValue(() => {
+        binding.track();
+        const capability = binding.kernel.tryCapability(valueOf(token), scoped() ?? undefined);
+        if (capability === null)
+            return fallback;
+        try {
+            return select(capability);
+        }
+        catch {
+            return fallback;
+        }
+    }, isEqual));
+}
+/**
+ * Subscribe to one of a capability's events while the component lives:
+ * `useCapabilityEvent(StageToken, (stage) => stage.onZoomChanged, handler)`. It subscribes again
+ * when the document in scope changes, and not at all without one. Events say what happened;
+ * the current value is a state reader's.
+ */
+export function useCapabilityEvent(token, select, handler) {
+    const capability = useOptionalCapability(token);
+    $effect(() => {
+        const current = capability.current;
+        if (!current)
+            return;
+        return untrack(() => select(current)((event) => handler(event)));
+    });
+}

package/dist/runtime/state.svelte.d.ts

@@ -0,0 +1,35 @@
+import type { CapabilityToken, SettingsOf, StateDeclaration } from '@embedpdf/core';
+import { type KernelBinding } from './binding.svelte.js';
+import { type CurrentValue, type MaybeGetter } from './values.svelte.js';
+/** A declared state's reader: the whole state, or the value `select` picks from it. */
+export interface StateReader<State extends object> {
+    (): Readonly<State>;
+    <Selected>(select: (state: State) => Selected): CurrentValue<Selected>;
+}
+/** A plugin's settings reader: the settings, or the value `select` picks from them. */
+export interface SettingsReader<Settings extends object> {
+    (): Readonly<Settings>;
+    <Selected>(select: (settings: Settings) => Selected): CurrentValue<Selected>;
+}
+/**
+ * The whole state, read through the capability `token` resolves for this subtree's document, or
+ * `empty` while it can't resolve. Resolved on every read: a document that closes reads as `empty`,
+ * never through its closed capability.
+ */
+export declare function declaredState<Capability, State extends object>(binding: KernelBinding, token: MaybeGetter<CapabilityToken<Capability>>, read: (capability: Capability) => State, empty: State): () => State;
+/** The reader's two forms over one getter: a reactive object with `keys`, or a selected value. */
+export declare function readRecord<Record extends object, Selected>(whole: () => Record, keys: readonly (keyof Record)[], select: ((record: Record) => Selected) | undefined): Readonly<Record> | CurrentValue<Selected>;
+/**
+ * Turn a state declaration into its reader. It reads this subtree's document (the nearest
+ * `<DocumentScope>`, else the active one) and gives the declaration's `empty` while that
+ * document is missing or not ready, so it works anywhere. State the plugin loads on demand
+ * (the declaration's `ensure`) loads once a ready document's capability is in scope.
+ */
+export declare function stateReader<Capability, State extends object>(declaration: StateDeclaration<Capability, State>): StateReader<State>;
+/**
+ * Turn a plugin's token into its settings reader. A plugin's settings belong to the plugin as
+ * the app registered it, not to a document, so the reader works before the first document opens
+ * and every document shows the same settings. `getSettings()` keeps its object until a setting
+ * changes. A token whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export declare function settingsReader<Capability>(token: CapabilityToken<Capability>): SettingsReader<SettingsOf<Capability> & object>;

package/dist/runtime/state.svelte.js

@@ -0,0 +1,90 @@
+/**
+ * Declared state and settings as Svelte readers. A plugin declares its state once with
+ * `defineState` and its settings once in its definition (both in `@embedpdf/core`), and its
+ * Svelte bindings are one line each:
+ *
+ *   export const useSearchState = stateReader(searchState);
+ *   export const useSearchSettings = settingsReader(SearchToken);
+ *
+ * Called with no argument, a reader returns a reactive object (`state.hitCount`), one derived
+ * value per field. Called with a selector, it returns the value the selector picks as
+ * `{ current }`, compared field by field so a fresh object passes nothing on until a field changes.
+ */
+import { untrack } from 'svelte';
+import { shallowEqual } from '@embedpdf/core';
+import { documentScopeOf, useKernelBinding } from './binding.svelte.js';
+import { currentOf, derivedValue, reactiveRecord, valueOf, } from './values.svelte.js';
+/**
+ * The whole state, read through the capability `token` resolves for this subtree's document, or
+ * `empty` while it can't resolve. Resolved on every read: a document that closes reads as `empty`,
+ * never through its closed capability.
+ */
+export function declaredState(binding, token, read, empty) {
+    const scoped = documentScopeOf();
+    return derivedValue(() => {
+        binding.track();
+        const capability = binding.kernel.tryCapability(valueOf(token), scoped() ?? undefined);
+        return capability ? read(capability) : empty;
+    }, shallowEqual);
+}
+/** The reader's two forms over one getter: a reactive object with `keys`, or a selected value. */
+export function readRecord(whole, keys, select) {
+    if (!select)
+        return reactiveRecord(whole, keys);
+    return currentOf(derivedValue(() => select(whole()), shallowEqual));
+}
+/**
+ * Load state the plugin loads on demand (`ensure`) for each capability the reader comes to read:
+ * once a ready document's capability is in scope, and again for the next document's.
+ */
+function ensureWhileRead(binding, token, ensure) {
+    const scoped = documentScopeOf();
+    let ensured = null;
+    $effect(() => {
+        binding.track();
+        const capability = binding.kernel.tryCapability(token, scoped() ?? undefined);
+        if (!capability || capability === ensured)
+            return;
+        ensured = capability;
+        // The state says when the load fails (its status), so the rejection has nothing to add.
+        untrack(() => ensure(capability).catch(() => { }));
+    });
+}
+/**
+ * Turn a state declaration into its reader. It reads this subtree's document (the nearest
+ * `<DocumentScope>`, else the active one) and gives the declaration's `empty` while that
+ * document is missing or not ready, so it works anywhere. State the plugin loads on demand
+ * (the declaration's `ensure`) loads once a ready document's capability is in scope.
+ */
+export function stateReader(declaration) {
+    const keys = Object.keys(declaration.empty);
+    const { ensure } = declaration;
+    return function useDeclaredState(select) {
+        const binding = useKernelBinding();
+        const whole = declaredState(binding, declaration.token, declaration.read, declaration.empty);
+        if (ensure)
+            ensureWhileRead(binding, declaration.token, ensure);
+        return readRecord(whole, keys, select);
+    };
+}
+/** A plugin's settings through the kernel: the same with or without a document. */
+function settingsOf(kernel, token) {
+    return kernel.settingsOf(token).getSettings();
+}
+/**
+ * Turn a plugin's token into its settings reader. A plugin's settings belong to the plugin as
+ * the app registered it, not to a document, so the reader works before the first document opens
+ * and every document shows the same settings. `getSettings()` keeps its object until a setting
+ * changes. A token whose plugin isn't installed, or has no settings, throws: a setup mistake.
+ */
+export function settingsReader(token) {
+    return function useSettings(select) {
+        const binding = useKernelBinding();
+        const initial = settingsOf(binding.kernel, token);
+        const whole = derivedValue(() => {
+            binding.track();
+            return settingsOf(binding.kernel, token);
+        }, shallowEqual);
+        return readRecord(whole, Object.keys(initial), select);
+    };
+}

package/dist/runtime/theme.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `epdfTheme()`: a theme written with setting names, as a `style` for the element around your
+ * viewer. The variables and their lookup are framework-free (`@embedpdf/web`); this writes them
+ * as the CSS text a Svelte `style` attribute takes.
+ */
+import { type EpdfTheme } from '@embedpdf/web';
+export type { EpdfTheme } from '@embedpdf/web';
+/**
+ * The CSS variables of a theme, for a `style` attribute: `<div style={epdfTheme({ accent })}>`.
+ * Everything inside the element follows them, and a CSS variable wins over any setting.
+ */
+export declare function epdfTheme(theme: EpdfTheme): string;

package/dist/runtime/theme.js

@@ -0,0 +1,15 @@
+/**
+ * `epdfTheme()`: a theme written with setting names, as a `style` for the element around your
+ * viewer. The variables and their lookup are framework-free (`@embedpdf/web`); this writes them
+ * as the CSS text a Svelte `style` attribute takes.
+ */
+import { epdfThemeVariables } from '@embedpdf/web';
+/**
+ * The CSS variables of a theme, for a `style` attribute: `<div style={epdfTheme({ accent })}>`.
+ * Everything inside the element follows them, and a CSS variable wins over any setting.
+ */
+export function epdfTheme(theme) {
+    return Object.entries(epdfThemeVariables(theme))
+        .map(([name, value]) => `${name}: ${value};`)
+        .join(' ');
+}

package/dist/runtime/values.svelte.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The two shapes a reader returns, and the derived value both are made of.
+ *
+ * - One value is `{ current }`, like Svelte's own `MediaQuery`: `pages.current`.
+ * - A record of named values (a plugin's state, its settings) is a reactive object whose fields
+ *   are getters: `state.zoomLevel`. Each field is its own `$derived`, so a template or an effect
+ *   that reads `zoomLevel` runs again only when `zoomLevel` changes.
+ */
+/** A value that changes: read `current` in a template, a `$derived` or an effect. */
+export interface CurrentValue<T> {
+    readonly current: T;
+}
+/** An argument that may change: the value, or a function that returns it (`() => note.ref`). */
+export type MaybeGetter<T> = T | (() => T);
+/** The value of a {@link MaybeGetter}. Only for values that are never functions themselves. */
+export declare function valueOf<T>(value: MaybeGetter<T>): T;
+/**
+ * A `$derived` that keeps its last value while `isEqual` says the new one is the same, so a value
+ * built fresh on every read (an object a selector returns) passes nothing on until a field changes.
+ */
+export declare function derivedValue<T>(compute: () => T, isEqual?: (left: T, right: T) => boolean): () => T;
+/** `{ current }` over a getter. */
+export declare function currentOf<T>(read: () => T): CurrentValue<T>;
+/**
+ * A reactive object with `keys` as getters over `whole()`, each its own derived value. The keys
+ * are fixed when it is made: a declared state's `empty`, or the settings it starts with.
+ */
+export declare function reactiveRecord<Record extends object>(whole: () => Record, keys: readonly (keyof Record)[]): Readonly<Record>;

package/dist/runtime/values.svelte.js

@@ -0,0 +1,51 @@
+/**
+ * The two shapes a reader returns, and the derived value both are made of.
+ *
+ * - One value is `{ current }`, like Svelte's own `MediaQuery`: `pages.current`.
+ * - A record of named values (a plugin's state, its settings) is a reactive object whose fields
+ *   are getters: `state.zoomLevel`. Each field is its own `$derived`, so a template or an effect
+ *   that reads `zoomLevel` runs again only when `zoomLevel` changes.
+ */
+/** The value of a {@link MaybeGetter}. Only for values that are never functions themselves. */
+export function valueOf(value) {
+    return typeof value === 'function' ? value() : value;
+}
+/**
+ * A `$derived` that keeps its last value while `isEqual` says the new one is the same, so a value
+ * built fresh on every read (an object a selector returns) passes nothing on until a field changes.
+ */
+export function derivedValue(compute, isEqual = Object.is) {
+    let last = null;
+    const value = $derived.by(() => {
+        const next = compute();
+        if (last !== null && isEqual(last.value, next))
+            return last.value;
+        last = { value: next };
+        return next;
+    });
+    return () => value;
+}
+/** `{ current }` over a getter. */
+export function currentOf(read) {
+    return {
+        get current() {
+            return read();
+        },
+    };
+}
+/** One field of a record, as its own `$derived`: it passes a change on only when the field changed. */
+function fieldOf(whole, key) {
+    const field = $derived(whole()[key]);
+    return () => field;
+}
+/**
+ * A reactive object with `keys` as getters over `whole()`, each its own derived value. The keys
+ * are fixed when it is made: a declared state's `empty`, or the settings it starts with.
+ */
+export function reactiveRecord(whole, keys) {
+    const record = {};
+    for (const key of keys) {
+        Object.defineProperty(record, key, { get: fieldOf(whole, key), enumerable: true });
+    }
+    return record;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @embedpdf/svelte/runtime — the generic binding.
+ *
+ * `<Viewer>` owns the kernel, and `<KernelProvider>` gives a subtree a kernel someone else owns;
+ * the readers turn its one change stream into Svelte reactivity and resolve capabilities against
+ * the document in scope (the active one, or a `<DocumentScope>`'s), with a stand-in while there is
+ * none; the page context is the seam every layer draws through. Every plugin binding is built from
+ * these. How to add one: this package's README.
+ */
+export * from '@embedpdf/core';
+export { mountWebFont, saveFile } from '@embedpdf/web';
+export { default as Viewer } from './runtime/Viewer.svelte';
+export { default as KernelProvider } from './runtime/KernelProvider.svelte';
+export { default as DocumentGate } from './runtime/DocumentGate.svelte';
+export { default as DocumentScope } from './runtime/DocumentScope.svelte';
+export type { DocumentGateProps, DocumentScopeProps, KernelProviderProps, ViewerProps, } from './runtime/props.js';
+export { useKernel } from './runtime/binding.svelte.js';
+export { shallowArray, useActiveDocumentId, useCapability, useCapabilityEvent, useDocumentId, useDocumentScope, useKernelValue, useOptionalCapability, useOptionalSelector, useSelector, } from './runtime/readers.svelte.js';
+export { useDocument, useDocuments, useDocumentsEvent, useDocumentsState, usePageList, useViewerSettings, } from './runtime/documents.svelte.js';
+export { settingsReader, stateReader } from './runtime/state.svelte.js';
+export type { SettingsReader, StateReader } from './runtime/state.svelte.js';
+export type { CurrentValue, MaybeGetter } from './runtime/values.svelte.js';
+export { makePageContext, setPageContext, usePage } from './runtime/page.js';
+export type { PageContextValue } from './runtime/page.js';
+export { epdfTheme } from './runtime/theme.js';
+export type { EpdfTheme } from './runtime/theme.js';

package/dist/runtime.js

@@ -0,0 +1,25 @@
+/**
+ * @embedpdf/svelte/runtime — the generic binding.
+ *
+ * `<Viewer>` owns the kernel, and `<KernelProvider>` gives a subtree a kernel someone else owns;
+ * the readers turn its one change stream into Svelte reactivity and resolve capabilities against
+ * the document in scope (the active one, or a `<DocumentScope>`'s), with a stand-in while there is
+ * none; the page context is the seam every layer draws through. Every plugin binding is built from
+ * these. How to add one: this package's README.
+ */
+// Registration travels with the UI: the kernel's types, tokens and helpers come from here too.
+export * from '@embedpdf/core';
+// What a page with a viewer needs from the browser: handing bytes to the user as a download,
+// and a font the engine draws with, for text you draw yourself.
+export { mountWebFont, saveFile } from '@embedpdf/web';
+export { default as Viewer } from './runtime/Viewer.svelte';
+export { default as KernelProvider } from './runtime/KernelProvider.svelte';
+export { default as DocumentGate } from './runtime/DocumentGate.svelte';
+export { default as DocumentScope } from './runtime/DocumentScope.svelte';
+export { useKernel } from './runtime/binding.svelte.js';
+export { shallowArray, useActiveDocumentId, useCapability, useCapabilityEvent, useDocumentId, useDocumentScope, useKernelValue, useOptionalCapability, useOptionalSelector, useSelector, } from './runtime/readers.svelte.js';
+export { useDocument, useDocuments, useDocumentsEvent, useDocumentsState, usePageList, useViewerSettings, } from './runtime/documents.svelte.js';
+export { settingsReader, stateReader } from './runtime/state.svelte.js';
+export { makePageContext, setPageContext, usePage } from './runtime/page.js';
+// A theme written with setting names, as the style for the element around a viewer.
+export { epdfTheme } from './runtime/theme.js';