@build-qube/papyra 0.0.4 → 0.2.0

package/dist/encode.js

@@ -0,0 +1,71 @@
+import { encodeBitmap, } from '@build-qube/papyra-native';
+import { encodedImage, } from './encoded.js';
+export { encodedImage, mimeType, svgPage } from './encoded.js';
+/**
+ * Encode a page you already hold — a cache hit, or one you have just painted.
+ *
+ * This copies the pixels back into Rust, because a `Uint8Array` points at the JS heap
+ * and cannot be held across the worker-thread boundary. When you do not also need the
+ * raw pixels, `doc.renderImage()` skips the round trip entirely.
+ */
+export async function encode(page, options = {}) {
+    const format = options.format ?? 'webp';
+    const bytes = await encodeBitmap(page.data, page.width, page.height, page.stride, format, options.quality, options.signal);
+    return encodedImage(bytes, format);
+}
+/**
+ * A page held in Rust, encoded on demand.
+ *
+ * The pixels never cross into JS. A 42x30in drawing at 150 DPI is 6.5 MB raw and a
+ * fraction of that encoded, so for export the raw buffer is pure overhead. There is no
+ * accessor for it on purpose: use `renderPage` when you want pixels, this when you
+ * want a file.
+ */
+export class PageImage {
+    #inner;
+    constructor(inner) {
+        this.#inner = inner;
+    }
+    /** Output width in pixels. */
+    get width() {
+        return this.#inner.width;
+    }
+    /** Output height in pixels. */
+    get height() {
+        return this.#inner.height;
+    }
+    /** Size of the *raw* bitmap still held in Rust. Encoded output is much smaller. */
+    get byteLength() {
+        return this.#inner.byteLength;
+    }
+    /** Encode to {@link EncodeOptions.format}, defaulting to WebP. */
+    async encode(options = {}) {
+        const format = options.format ?? 'webp';
+        const bytes = await this.#inner.encode(format, options.quality, options.signal);
+        return encodedImage(bytes, format);
+    }
+    /** Lossless VP8L. The default, and ~3x smaller than PNG on page content. */
+    toWebp(options = {}) {
+        return this.encode({ ...options, format: 'webp' });
+    }
+    /** Lossless PNG. Reach for it when the consumer cannot be trusted to read WebP. */
+    toPng(options = {}) {
+        return this.encode({ ...options, format: 'png' });
+    }
+    /**
+     * Lossy JPEG at `quality` (1-100, default 80).
+     *
+     * No alpha: transparent pixels composite onto white, matching how pages render.
+     */
+    toJpeg(quality, options = {}) {
+        return this.encode({ ...options, format: 'jpeg', quality });
+    }
+    /**
+     * Encode straight to a `data:` URL. Nothing but the finished string crosses the
+     * boundary — not the pixels, not the encoded bytes.
+     */
+    toDataUrl(options = {}) {
+        return this.#inner.toDataUrl((options.format ?? 'webp'), options.quality, options.signal);
+    }
+}
+//# sourceMappingURL=encode.js.map

package/dist/encode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../src/encode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,GAGb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAGL,YAAY,GACb,MAAM,cAAc,CAAC;AAUtB,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM,CAC1B,IAAkB,EAClB,OAAO,GAAkB,EAAE;IAE3B,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC;IACxC,MAAM,KAAK,GAAG,MAAM,YAAY,CAC9B,IAAI,CAAC,IAAI,EACT,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,MAAM,EACX,MAAsB,EACtB,OAAO,CAAC,OAAO,EACf,OAAO,CAAC,MAAM,CACf,CAAC;IACF,OAAO,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,SAAS;IACX,MAAM,CAAkB;IAEjC,YAAY,KAAsB;QAChC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,8BAA8B;IAC9B,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED,+BAA+B;IAC/B,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;IAC5B,CAAC;IAED,mFAAmF;IACnF,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;IAChC,CAAC;IAED,kEAAkE;IAClE,KAAK,CAAC,MAAM,CAAC,OAAO,GAAkB,EAAE;QACtC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC;QACxC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CACpC,MAAsB,EACtB,OAAO,CAAC,OAAO,EACf,OAAO,CAAC,MAAM,CACf,CAAC;QACF,OAAO,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,CAAC;IAED,4EAA4E;IAC5E,MAAM,CAAC,OAAO,GAA8C,EAAE;QAC5D,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,mFAAmF;IACnF,KAAK,CAAC,OAAO,GAA8C,EAAE;QAC3D,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,OAAgB,EAAE,OAAO,GAAkC,EAAE;QAClE,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,OAAO,GAAkB,EAAE;QACnC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAC1B,CAAC,OAAO,CAAC,MAAM,IAAI,MAAM,CAAiB,EAC1C,OAAO,CAAC,OAAO,EACf,OAAO,CAAC,MAAM,CACf,CAAC;IACJ,CAAC;CACF"}

package/dist/encoded.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The parts of encoding that touch no native code.
+ *
+ * Split from `encode.ts` because CI's `unit-test` job runs with no Rust toolchain and
+ * no build: anything `test/unit` imports must not pull in the addon, and `encode.ts`
+ * imports `encodeBitmap` as a value. See CLAUDE.md.
+ */
+/**
+ * Containers papyra can rasterise a page into. All three encoders are pure Rust — that
+ * is what keeps the browser build free of a C toolchain — so there is no lossy WebP and
+ * no AVIF.
+ *
+ * - `webp` is lossless VP8L, and the default: on page content (line art, text, flat
+ *   fills) it is ~3x smaller than PNG for roughly the same encode time.
+ * - `png` is the universal fallback.
+ * - `jpeg` is the only lossy option and the only one with a `quality` knob. It has no
+ *   alpha channel; transparent pixels are composited onto white, matching how pages
+ *   are rendered.
+ */
+export type RasterFormat = 'webp' | 'png' | 'jpeg';
+/**
+ * Every container papyra can write, {@link RasterFormat} plus `svg`.
+ *
+ * `svg` is separate from the others everywhere it matters: it comes off
+ * `Document.renderSvg`, not off pixels, so it takes no DPI and no quality — which is
+ * why {@link EncodeOptions.format} accepts only a {@link RasterFormat}.
+ */
+export type EncodedFormat = RasterFormat | 'svg';
+/** MIME type for an encoded format, e.g. `'webp'` -> `'image/webp'`. */
+export declare function mimeType(format: EncodedFormat): string;
+/** Which container to write, and how hard to squeeze. */
+export interface EncodeOptions {
+    /**
+     * Defaults to `'webp'`. Rasters only — SVG is not an encoding of a bitmap, so it
+     * comes from `Document.renderSvg` instead.
+     */
+    format?: RasterFormat;
+    /** JPEG only, 1-100. Defaults to 80. Ignored by the lossless formats. */
+    quality?: number;
+    /** Abort a request that has not started yet. */
+    signal?: AbortSignal;
+}
+/** Encoded bytes, plus the three ways you are likely to want to hand them to a browser. */
+export interface EncodedImage {
+    /** The encoded file, ready to write to disk or upload. */
+    readonly bytes: Uint8Array;
+    /** The container {@link bytes} is written in. */
+    readonly format: EncodedFormat;
+    /** MIME type for {@link format}, so a caller never has to map it back. */
+    readonly mime: string;
+    /** Wrap as a `Blob`, ready for `URL.createObjectURL` or an upload. */
+    toBlob(): Blob;
+    /**
+     * An object URL for `<img src>`. Prefer this over {@link toDataUrl} in a browser:
+     * no base64 inflation, no multi-megabyte string on the heap, and the decoder reads
+     * straight from the blob.
+     *
+     * The caller owns the URL — `URL.revokeObjectURL` it when the image is gone.
+     */
+    toBlobUrl(): string;
+    /**
+     * A `data:` URL. For an `<img src>` this is the worse option; reach for it when the
+     * bytes must be embedded — CSS, serialised output, server-rendered HTML.
+     */
+    toDataUrl(): string;
+}
+/**
+ * One page as SVG. An {@link EncodedImage} whose markup is also readable as a string,
+ * because the usual thing to do with an SVG is inline it rather than hand a browser
+ * a URL.
+ */
+export interface SvgPage extends EncodedImage {
+    readonly format: 'svg';
+    /** The SVG document itself, a single `<svg>` element sized in PDF points. */
+    readonly markup: string;
+}
+/**
+ * Wrap SVG markup as an {@link SvgPage}.
+ *
+ * `bytes` is encoded on first access: inlining the markup is the common case, and a
+ * page of dense line art is megabytes of text that no one asked to have copied.
+ */
+export declare function svgPage(markup: string): SvgPage;
+/**
+ * Wrap already-encoded bytes as an {@link EncodedImage}.
+ *
+ * Exported for callers holding bytes from somewhere else — a cache, a fetch — that
+ * want the same `toBlob`/`toBlobUrl`/`toDataUrl` conveniences.
+ */
+export declare function encodedImage(bytes: Uint8Array, format: EncodedFormat): EncodedImage;
+//# sourceMappingURL=encoded.d.ts.map

package/dist/encoded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoded.d.ts","sourceRoot":"","sources":["../src/encoded.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,KAAK,CAAC;AASjD,wEAAwE;AACxE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAEtD;AAED,yDAAyD;AACzD,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,2FAA2F;AAC3F,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,MAAM,IAAI,IAAI,CAAC;IACf;;;;;;OAMG;IACH,SAAS,IAAI,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,IAAI,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,OAAQ,SAAQ,YAAY;IAC3C,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAqB/C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,aAAa,GACpB,YAAY,CAYd"}

package/dist/encoded.js

@@ -0,0 +1,84 @@
+const MIME = {
+    webp: 'image/webp',
+    png: 'image/png',
+    jpeg: 'image/jpeg',
+    svg: 'image/svg+xml',
+};
+/** MIME type for an encoded format, e.g. `'webp'` -> `'image/webp'`. */
+export function mimeType(format) {
+    return MIME[format];
+}
+/**
+ * Wrap SVG markup as an {@link SvgPage}.
+ *
+ * `bytes` is encoded on first access: inlining the markup is the common case, and a
+ * page of dense line art is megabytes of text that no one asked to have copied.
+ */
+export function svgPage(markup) {
+    const mime = MIME.svg;
+    let encoded;
+    const bytes = () => {
+        encoded ??= new TextEncoder().encode(markup);
+        return encoded;
+    };
+    return {
+        markup,
+        format: 'svg',
+        mime,
+        get bytes() {
+            return bytes();
+        },
+        toBlob: () => new Blob([markup], { type: mime }),
+        toBlobUrl() {
+            return URL.createObjectURL(this.toBlob());
+        },
+        toDataUrl: () => `data:${mime};base64,${base64(bytes())}`,
+    };
+}
+/**
+ * Wrap already-encoded bytes as an {@link EncodedImage}.
+ *
+ * Exported for callers holding bytes from somewhere else — a cache, a fetch — that
+ * want the same `toBlob`/`toBlobUrl`/`toDataUrl` conveniences.
+ */
+export function encodedImage(bytes, format) {
+    const mime = MIME[format];
+    return {
+        bytes,
+        format,
+        mime,
+        toBlob: () => new Blob([detach(bytes)], { type: mime }),
+        toBlobUrl() {
+            return URL.createObjectURL(this.toBlob());
+        },
+        toDataUrl: () => `data:${mime};base64,${base64(bytes)}`,
+    };
+}
+/**
+ * Copy into a buffer `Blob` will accept.
+ *
+ * On the wasm build these bytes live in the module's shared linear memory, and
+ * `SharedArrayBuffer`-backed views are not valid `BlobPart`s. Copying unconditionally
+ * keeps both runtimes on one path; encoded output is small enough that it does not
+ * matter, which is exactly why `toImageData` cannot do the same trick cheaply.
+ */
+function detach(bytes) {
+    const out = new Uint8Array(bytes.byteLength);
+    out.set(bytes);
+    return out;
+}
+function base64(bytes) {
+    const buf = globalThis.Buffer;
+    // Node's native base64 beats anything expressible in JS by a wide margin.
+    if (buf)
+        return buf.from(bytes).toString('base64');
+    // btoa wants a binary string, and spreading into fromCharCode overflows the stack
+    // somewhere north of 100k arguments. Chunk it.
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    return btoa(binary);
+}
+//# sourceMappingURL=encoded.js.map

package/dist/encoded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoded.js","sourceRoot":"","sources":["../src/encoded.ts"],"names":[],"mappings":"AA8BA,MAAM,IAAI,GAAkC;IAC1C,IAAI,EAAE,YAAY;IAClB,GAAG,EAAE,WAAW;IAChB,IAAI,EAAE,YAAY;IAClB,GAAG,EAAE,eAAe;CACrB,CAAC;AAEF,wEAAwE;AACxE,MAAM,UAAU,QAAQ,CAAC,MAAqB;IAC5C,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC;AAmDD;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,MAAc;IACpC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC;IACtB,IAAI,OAA+B,CAAC;IACpC,MAAM,KAAK,GAAG,GAAe,EAAE;QAC7B,OAAO,KAAK,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC7C,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC;IAEF,OAAO;QACL,MAAM;QACN,MAAM,EAAE,KAAK;QACb,IAAI;QACJ,IAAI,KAAK;YACP,OAAO,KAAK,EAAE,CAAC;QACjB,CAAC;QACD,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QAChD,SAAS;YACP,OAAO,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5C,CAAC;QACD,SAAS,EAAE,GAAG,EAAE,CAAC,QAAQ,IAAI,WAAW,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE;KAC1D,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC1B,KAAiB,EACjB,MAAqB;IAErB,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,OAAO;QACL,KAAK;QACL,MAAM;QACN,IAAI;QACJ,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACvD,SAAS;YACP,OAAO,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5C,CAAC;QACD,SAAS,EAAE,GAAG,EAAE,CAAC,QAAQ,IAAI,WAAW,MAAM,CAAC,KAAK,CAAC,EAAE;KACxD,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,MAAM,CAAC,KAAiB;IAC/B,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAC7C,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACf,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,MAAM,CAAC,KAAiB;IAC/B,MAAM,GAAG,GACP,UAGD,CAAC,MAAM,CAAC;IACT,0EAA0E;IAC1E,IAAI,GAAG;QAAE,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAEnD,kFAAkF;IAClF,+CAA+C;IAC/C,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,MAAM,KAAK,GAAG,MAAM,CAAC;IACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;QAC7C,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IACjE,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A document that could not be opened because of its password.
+ *
+ * The base of both password failures, because a viewer handles them in one place: a
+ * dialog that either asks for the first time or says the last answer was wrong.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   doc = await open(file, { password });
+ * } catch (e) {
+ *   if (e instanceof PasswordError) showPasswordDialog({ retry: e.retry });
+ *   else throw e;
+ * }
+ * ```
+ */
+export declare class PasswordError extends Error {
+    /**
+     * A password was already tried and rejected.
+     *
+     * `false` the first time, so a dialog can open without an error on it.
+     */
+    readonly retry: boolean;
+}
+/** The document is encrypted and {@link OpenOptions.password} was not supplied. */
+export declare class PasswordRequiredError extends PasswordError {
+    /** Always `'PasswordRequiredError'`. */
+    readonly name = "PasswordRequiredError";
+    readonly retry = false;
+    constructor(message?: string);
+}
+/** A password was supplied and it did not open the document. */
+export declare class IncorrectPasswordError extends PasswordError {
+    /** Always `'IncorrectPasswordError'`. */
+    readonly name = "IncorrectPasswordError";
+    readonly retry = true;
+    constructor(message?: string);
+}
+/**
+ * Rethrow a load failure as itself, or as the typed error it was tagged as.
+ *
+ * @internal
+ */
+export declare function rethrowLoadError(error: unknown): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAS;CACjC;AAED,mFAAmF;AACnF,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,wCAAwC;IACxC,SAAkB,IAAI,2BAA2B;IACjD,SAAkB,KAAK,SAAS;IAChC,YAAY,OAAO,SAAmC,EAErD;CACF;AAED,gEAAgE;AAChE,qBAAa,sBAAuB,SAAQ,aAAa;IACvD,yCAAyC;IACzC,SAAkB,IAAI,4BAA4B;IAClD,SAAkB,KAAK,QAAQ;IAC/B,YAAY,OAAO,SAAuC,EAEzD;CACF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAQtD"}

package/dist/errors.js

@@ -0,0 +1,69 @@
+/**
+ * Tags the bindings put in front of a load failure's message.
+ *
+ * napi-rs gives every error it throws the same `code`, so the message is the only
+ * channel a typed failure can travel through. These are stripped before the error
+ * reaches a caller — keep them in step with `TAG_PASSWORD_REQUIRED` and
+ * `TAG_INCORRECT_PASSWORD` in `packages/bindings/src/lib.rs`.
+ */
+const TAGS = {
+    'papyra/password-required': (message) => new PasswordRequiredError(message),
+    'papyra/incorrect-password': (message) => new IncorrectPasswordError(message),
+};
+/**
+ * A document that could not be opened because of its password.
+ *
+ * The base of both password failures, because a viewer handles them in one place: a
+ * dialog that either asks for the first time or says the last answer was wrong.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   doc = await open(file, { password });
+ * } catch (e) {
+ *   if (e instanceof PasswordError) showPasswordDialog({ retry: e.retry });
+ *   else throw e;
+ * }
+ * ```
+ */
+export class PasswordError extends Error {
+    /**
+     * A password was already tried and rejected.
+     *
+     * `false` the first time, so a dialog can open without an error on it.
+     */
+    retry = false;
+}
+/** The document is encrypted and {@link OpenOptions.password} was not supplied. */
+export class PasswordRequiredError extends PasswordError {
+    /** Always `'PasswordRequiredError'`. */
+    name = 'PasswordRequiredError';
+    retry = false;
+    constructor(message = 'this PDF is password-protected') {
+        super(message);
+    }
+}
+/** A password was supplied and it did not open the document. */
+export class IncorrectPasswordError extends PasswordError {
+    /** Always `'IncorrectPasswordError'`. */
+    name = 'IncorrectPasswordError';
+    retry = true;
+    constructor(message = 'the supplied password is incorrect') {
+        super(message);
+    }
+}
+/**
+ * Rethrow a load failure as itself, or as the typed error it was tagged as.
+ *
+ * @internal
+ */
+export function rethrowLoadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    for (const [tag, build] of Object.entries(TAGS)) {
+        if (message.startsWith(tag)) {
+            throw build(message.slice(tag.length).trim());
+        }
+    }
+    throw error;
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,IAAI,GAAG;IACX,0BAA0B,EAAE,CAAC,OAAe,EAAE,EAAE,CAC9C,IAAI,qBAAqB,CAAC,OAAO,CAAC;IACpC,2BAA2B,EAAE,CAAC,OAAe,EAAE,EAAE,CAC/C,IAAI,sBAAsB,CAAC,OAAO,CAAC;CAC7B,CAAC;AAEX;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,aAAc,SAAQ,KAAK;IACtC;;;;OAIG;IACM,KAAK,GAAY,KAAK,CAAC;CACjC;AAED,mFAAmF;AACnF,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IACtD,wCAAwC;IACtB,IAAI,GAAG,uBAAuB,CAAC;IAC/B,KAAK,GAAG,KAAK,CAAC;IAChC,YAAY,OAAO,GAAG,gCAAgC;QACpD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;CACF;AAED,gEAAgE;AAChE,MAAM,OAAO,sBAAuB,SAAQ,aAAa;IACvD,yCAAyC;IACvB,IAAI,GAAG,wBAAwB,CAAC;IAChC,KAAK,GAAG,IAAI,CAAC;IAC/B,YAAY,OAAO,GAAG,oCAAoC;QACxD,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAChD,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IACD,MAAM,KAAK,CAAC;AACd,CAAC"}

package/dist/fingerprint.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A stable identifier for a document's bytes.
+ *
+ * Sixteen hex characters, derived from the head, the tail and the length of the file.
+ * Meant as a key for whatever a viewer remembers per document — the page it was left
+ * on, the zoom, a set of highlights.
+ *
+ * **This is a content hash, not the PDF's `/ID`.** hayro exposes no trailer accessor,
+ * so the identifier the spec defines is out of reach; the practical difference is
+ * that a document saved with an incremental update keeps its `/ID` and gets a new
+ * fingerprint here. For "is this the same file I had open", which is what the value
+ * is for, hashing the bytes is the stronger answer anyway — it also distinguishes two
+ * documents that were copied from one another and kept the same `/ID`.
+ *
+ * @internal
+ */
+export declare function fingerprint(bytes: Uint8Array): string;
+//# sourceMappingURL=fingerprint.d.ts.map

package/dist/fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.d.ts","sourceRoot":"","sources":["../src/fingerprint.ts"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAarD"}

package/dist/fingerprint.js

@@ -0,0 +1,48 @@
+/**
+ * How many bytes to read from each end of the file.
+ *
+ * The tail is the load-bearing half: it holds the cross-reference table and the
+ * trailer, and the trailer is where `/ID` lives. So although this never parses the
+ * document, a file that carries an `/ID` still contributes it to the hash.
+ */
+const SAMPLE = 4096;
+/** FNV-1a, 32-bit. Two runs at different offsets give the 64 bits below. */
+function fnv1a(bytes, seed) {
+    let hash = seed;
+    for (const byte of bytes) {
+        hash ^= byte;
+        // The FNV prime, 16777619, as shifts — `Math.imul` keeps this in 32 bits where
+        // `*` would silently go through a double and lose the low bits.
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+/**
+ * A stable identifier for a document's bytes.
+ *
+ * Sixteen hex characters, derived from the head, the tail and the length of the file.
+ * Meant as a key for whatever a viewer remembers per document — the page it was left
+ * on, the zoom, a set of highlights.
+ *
+ * **This is a content hash, not the PDF's `/ID`.** hayro exposes no trailer accessor,
+ * so the identifier the spec defines is out of reach; the practical difference is
+ * that a document saved with an incremental update keeps its `/ID` and gets a new
+ * fingerprint here. For "is this the same file I had open", which is what the value
+ * is for, hashing the bytes is the stronger answer anyway — it also distinguishes two
+ * documents that were copied from one another and kept the same `/ID`.
+ *
+ * @internal
+ */
+export function fingerprint(bytes) {
+    const head = bytes.subarray(0, SAMPLE);
+    // `subarray` clamps, so a file shorter than one sample simply hashes twice rather
+    // than needing a branch.
+    const tail = bytes.subarray(Math.max(0, bytes.length - SAMPLE));
+    const low = fnv1a(tail, fnv1a(head, 0x811c9dc5));
+    // A second pass from a different seed, so the two halves of the output are not the
+    // same 32 bits twice. Length goes in as well: it separates a file from its own
+    // prefix, which the samples alone would not.
+    const high = fnv1a(tail, fnv1a(head, bytes.length >>> 0));
+    return high.toString(16).padStart(8, '0') + low.toString(16).padStart(8, '0');
+}
+//# sourceMappingURL=fingerprint.js.map

package/dist/fingerprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.js","sourceRoot":"","sources":["../src/fingerprint.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,GAAG,IAAI,CAAC;AAEpB,4EAA4E;AAC5E,SAAS,KAAK,CAAC,KAAiB,EAAE,IAAY;IAC5C,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,IAAI,CAAC;QACb,+EAA+E;QAC/E,gEAAgE;QAChE,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,CAAC;AACpB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CAAC,KAAiB;IAC3C,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IACvC,kFAAkF;IAClF,yBAAyB;IACzB,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;IAEhE,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;IACjD,mFAAmF;IACnF,+EAA+E;IAC/E,6CAA6C;IAC7C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;IAE1D,OAAO,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAChF,CAAC"}

package/dist/index.d.ts

@@ -15,11 +15,21 @@
  */
 export type { CacheStats } from './cache.js';
 export { paintToCanvas, toImageData } from './canvas.js';
-export type { RenderHandle } from './document.js';
+export type { ImageHandle, RenderHandle, SvgHandle } from './document.js';
 export { Document, open } from './document.js';
+export type { EncodedFormat, EncodedImage, EncodeOptions, RasterFormat, SvgPage, } from './encode.js';
+export { encode, encodedImage, mimeType, PageImage, svgPage, } from './encode.js';
+export { IncorrectPasswordError, PasswordError, PasswordRequiredError, } from './errors.js';
+export type { LinkTarget, PageLink } from './links.js';
+export type { DestinationKind, OutlineDestination, OutlineNode, } from './outline.js';
+export { buildOutlineTree, walkOutline } from './outline.js';
 export type { Runtime } from './runtime.js';
 export { backend, currentRuntime, hardwareConcurrency, init, } from './runtime.js';
 export type { JobHandle, JobTiming } from './scheduler.js';
 export { AbortError, DEFAULT_PRIORITY } from './scheduler.js';
-export type { OpenOptions, PageSize, PdfSource, RenderedPage, RenderOptions, StreamedPage, StreamOptions, } from './types.js';
+export type { MatchOptions, SearchMatch } from './search.js';
+export { findRanges, searchPageText } from './search.js';
+export type { PageText, Quad, Rect, TextLine } from './text.js';
+export { lineQuad, pageString, quadBounds, scaleQuad, scaleRect, } from './text.js';
+export type { DocumentMetadata, OpenOptions, PageSize, PdfSource, RenderedPage, RenderOptions, SearchOptions, StreamedPage, StreamOptions, SvgOptions, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EACL,OAAO,EACP,cAAc,EACd,mBAAmB,EACnB,IAAI,GACL,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC9D,YAAY,EACV,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,OAAO,GACR,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,MAAM,EACN,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,OAAO,GACR,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,sBAAsB,EACtB,aAAa,EACb,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACvD,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC7D,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EACL,OAAO,EACP,cAAc,EACd,mBAAmB,EACnB,IAAI,GACL,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC9D,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EACL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,SAAS,EACT,SAAS,GACV,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,aAAa,EACb,aAAa,EACb,YAAY,EACZ,aAAa,EACb,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -15,6 +15,11 @@
  */
 export { paintToCanvas, toImageData } from './canvas.js';
 export { Document, open } from './document.js';
+export { encode, encodedImage, mimeType, PageImage, svgPage, } from './encode.js';
+export { IncorrectPasswordError, PasswordError, PasswordRequiredError, } from './errors.js';
+export { buildOutlineTree, walkOutline } from './outline.js';
 export { backend, currentRuntime, hardwareConcurrency, init, } from './runtime.js';
 export { AbortError, DEFAULT_PRIORITY } from './scheduler.js';
+export { findRanges, searchPageText } from './search.js';
+export { lineQuad, pageString, quadBounds, scaleQuad, scaleRect, } from './text.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,EACL,OAAO,EACP,cAAc,EACd,mBAAmB,EACnB,IAAI,GACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAQ/C,OAAO,EACL,MAAM,EACN,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,OAAO,GACR,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,sBAAsB,EACtB,aAAa,EACb,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAOrB,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE7D,OAAO,EACL,OAAO,EACP,cAAc,EACd,mBAAmB,EACnB,IAAI,GACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE9D,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EACL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,SAAS,EACT,SAAS,GACV,MAAM,WAAW,CAAC"}

package/dist/links.d.ts

@@ -0,0 +1,53 @@
+import type { PageLink as NativePageLink } from '@build-qube/papyra-native';
+import { type OutlineDestination } from './outline.js';
+import type { Rect } from './text.js';
+/**
+ * Where a link goes.
+ *
+ * A discriminated union rather than two nullable fields, so narrowing on `kind` gives
+ * you the payload without a non-null assertion:
+ *
+ * ```ts
+ * if (link.target.kind === 'uri') window.open(link.target.uri);
+ * else void doc.render(link.target.dest.page, { fitWidth: 1600 });
+ * ```
+ */
+export type LinkTarget = {
+    /** The link points somewhere in this document. */
+    readonly kind: 'internal';
+    /** The page and the view, in the same shape an outline entry uses. */
+    readonly dest: OutlineDestination;
+} | {
+    /**
+     * The link points out of this document.
+     *
+     * Not necessarily `http`: `mailto:` and `file:` are both common, and papyra
+     * does not validate the string. Decide for yourself what you are willing to
+     * follow before handing it to a browser.
+     */
+    readonly kind: 'uri';
+    /** The URI, exactly as the document wrote it. */
+    readonly uri: string;
+};
+/**
+ * One link on a page: a clickable region, and what it does.
+ *
+ * Only links that resolve to something actionable are reported — a `/Link` pointing
+ * at a page the document does not contain, or carrying an action papyra does not act
+ * on, is dropped rather than handed over as a region that would swallow clicks.
+ */
+export interface PageLink {
+    /**
+     * The clickable region, in the same 72-DPI top-left space as {@link PageText} and
+     * {@link PageSize}. Multiply by `rendered.width / pageSize.width` to place it over
+     * a render — {@link scaleRect} does exactly that.
+     */
+    readonly rect: Rect;
+    /** Where activating the link goes. Narrow on `target.kind`. */
+    readonly target: LinkTarget;
+    /** The annotation's tooltip, when it has one. */
+    readonly alt: string | null;
+}
+/** @internal */
+export declare function toPageLink(native: NativePageLink): PageLink | null;
+//# sourceMappingURL=links.d.ts.map

package/dist/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../src/links.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,KAAK,kBAAkB,EAAiB,MAAM,cAAc,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,GAClB;IACE,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;CACnC,GACD;IACE;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,iDAAiD;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,iDAAiD;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,gBAAgB;AAChB,wBAAgB,UAAU,CAAC,MAAM,EAAE,cAAc,GAAG,QAAQ,GAAG,IAAI,CAelE"}

package/dist/links.js

@@ -0,0 +1,26 @@
+import { toDestination } from './outline.js';
+/** @internal */
+export function toPageLink(native) {
+    const target = linkTarget(native);
+    // The bindings only emit a link with one target or the other, so this is
+    // unreachable in practice; dropping it beats widening the type with a null target.
+    if (!target)
+        return null;
+    return {
+        rect: {
+            x: native.x0,
+            y: native.y0,
+            width: native.x1 - native.x0,
+            height: native.y1 - native.y0,
+        },
+        target,
+        alt: native.alt ?? null,
+    };
+}
+function linkTarget(native) {
+    if (native.uri !== undefined)
+        return { kind: 'uri', uri: native.uri };
+    const dest = toDestination(native.dest);
+    return dest ? { kind: 'internal', dest } : null;
+}
+//# sourceMappingURL=links.js.map

package/dist/links.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.js","sourceRoot":"","sources":["../src/links.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,aAAa,EAAE,MAAM,cAAc,CAAC;AAsDtE,gBAAgB;AAChB,MAAM,UAAU,UAAU,CAAC,MAAsB;IAC/C,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAClC,yEAAyE;IACzE,mFAAmF;IACnF,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,OAAO;QACL,IAAI,EAAE;YACJ,CAAC,EAAE,MAAM,CAAC,EAAE;YACZ,CAAC,EAAE,MAAM,CAAC,EAAE;YACZ,KAAK,EAAE,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,EAAE;YAC5B,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,EAAE;SAC9B;QACD,MAAM;QACN,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,IAAI;KACxB,CAAC;AACJ,CAAC;AAED,SAAS,UAAU,CAAC,MAAsB;IACxC,IAAI,MAAM,CAAC,GAAG,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC;IACtE,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACxC,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAClD,CAAC"}