web-doc 0.3.0

package/dist/adapters/pdf.d.ts

@@ -0,0 +1,32 @@
+import type { AdapterOpenContext, DocumentAdapter, DocumentInfo, PageSize, RenderViewport, TextRun } from "../contracts.js";
+export interface PdfBackend {
+    readonly pageCount: number;
+    pageSize?(pageIndex: number, signal?: AbortSignal): PageSize | Promise<PageSize>;
+    renderPage(target: HTMLCanvasElement | OffscreenCanvas, pageIndex: number, zoom: number, devicePixelRatio: number, signal?: AbortSignal): Promise<void>;
+    pageText(pageIndex: number, signal?: AbortSignal): Promise<readonly TextRun[]>;
+    close(): void | Promise<void>;
+}
+export interface PdfAdapterOptions {
+    readonly workerUrl?: string | URL;
+    readonly cMapUrl?: string | URL;
+    readonly standardFontDataUrl?: string | URL;
+    readonly wasmUrl?: string | URL;
+    readonly iccUrl?: string | URL;
+    readonly open?: (data: Uint8Array, context: AdapterOpenContext) => Promise<PdfBackend>;
+}
+interface PdfHandle {
+    readonly backend: PdfBackend;
+}
+export declare class PdfDocumentAdapter implements DocumentAdapter<PdfHandle> {
+    #private;
+    readonly id = "pdf";
+    readonly formats: readonly ["pdf"];
+    constructor(options?: PdfAdapterOptions);
+    open(data: Uint8Array, context: AdapterOpenContext): Promise<PdfHandle>;
+    getInfo(handle: PdfHandle): Promise<DocumentInfo>;
+    render(handle: PdfHandle, target: HTMLCanvasElement | OffscreenCanvas, viewport: RenderViewport, signal?: AbortSignal): Promise<void>;
+    getTextMap(handle: PdfHandle, pageIndex: number, signal?: AbortSignal): Promise<readonly TextRun[]>;
+    close(handle: PdfHandle): Promise<void>;
+}
+export declare function createPdfAdapter(options?: PdfAdapterOptions): PdfDocumentAdapter;
+export {};

package/dist/adapters/pdf.js

@@ -0,0 +1,429 @@
+import { abortError, ViewerError } from "../errors.js";
+// Preserve the public zoom=1 contract: one PDF point maps to one renderer CSS
+// pixel. Per-page geometry still prevents the viewport from coercing pages to
+// A4 or changing their width while virtualizing.
+const CSS_UNITS = 1;
+export class PdfDocumentAdapter {
+    id = "pdf";
+    formats = ["pdf"];
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    async open(data, context) {
+        context.reportProgress({ phase: "parsing", loaded: 0, total: 1 });
+        try {
+            const backend = this.#options.open
+                ? await this.#options.open(data, context)
+                : await PdfJsBackend.open(data, context, this.#options);
+            if (context.signal.aborted) {
+                await backend.close();
+                throw abortError();
+            }
+            if (backend.pageCount < 1) {
+                await backend.close();
+                throw new ViewerError("invalid-file", "PDF contains no pages");
+            }
+            context.reportProgress({
+                phase: "parsing",
+                loaded: 1,
+                total: 1,
+                ratio: 1,
+            });
+            return { backend };
+        }
+        catch (error) {
+            if (context.signal.aborted)
+                throw abortError();
+            if (error instanceof ViewerError)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            throw new ViewerError(isPasswordError(error, message) ? "encrypted-document" : "invalid-file", isPasswordError(error, message)
+                ? "Password-protected PDF documents are not supported"
+                : message, { cause: error });
+        }
+    }
+    async getInfo(handle) {
+        const pageSizes = handle.backend.pageSize
+            ? await Promise.all(Array.from({ length: handle.backend.pageCount }, (_, pageIndex) => handle.backend.pageSize(pageIndex)))
+            : undefined;
+        return {
+            format: "pdf",
+            unit: "page",
+            pageCount: handle.backend.pageCount,
+            ...(pageSizes ? { pageSizes } : {}),
+        };
+    }
+    async render(handle, target, viewport, signal) {
+        assertPage(viewport.pageIndex, handle.backend.pageCount);
+        if (signal?.aborted)
+            throw abortError();
+        await handle.backend.renderPage(target, viewport.pageIndex, viewport.zoom, viewport.devicePixelRatio, signal);
+        if (signal?.aborted)
+            throw abortError();
+    }
+    async getTextMap(handle, pageIndex, signal) {
+        assertPage(pageIndex, handle.backend.pageCount);
+        if (signal?.aborted)
+            throw abortError();
+        return handle.backend.pageText(pageIndex, signal);
+    }
+    async close(handle) {
+        await handle.backend.close();
+    }
+}
+export function createPdfAdapter(options = {}) {
+    return new PdfDocumentAdapter(options);
+}
+class PdfJsBackend {
+    pageCount;
+    #module;
+    #document;
+    #worker;
+    #loadingTask;
+    #maxPixels;
+    #pages = new Map();
+    #closed = false;
+    constructor(module, document, worker, loadingTask, maxPixels) {
+        this.#module = module;
+        this.#document = document;
+        this.#worker = worker;
+        this.#loadingTask = loadingTask;
+        this.#maxPixels = maxPixels;
+        this.pageCount = document.numPages;
+    }
+    static async open(data, context, options) {
+        if (typeof Worker === "undefined")
+            throw new ViewerError("internal", "PDF.js requires a browser module Worker");
+        // PDF.js' modern build targets browsers with very recent JavaScript
+        // intrinsics (for example Math.sumPrecise). The legacy build keeps the
+        // same API while installing the required polyfills in both the main
+        // realm and its matching worker, which is necessary for our supported
+        // browser matrix.
+        const module = (await import("pdfjs-dist/legacy/build/pdf.mjs"));
+        const assetRoot = context.assetBaseUrl
+            ? new URL("assets/pdfjs/", context.assetBaseUrl)
+            : packageRelativeUrl(["..", "assets", "pdfjs", ""]);
+        const defaultWorkerUrl = context.assetBaseUrl
+            ? new URL("workers/pdf.worker.min.mjs", context.assetBaseUrl)
+            : packageRelativeUrl(["..", "workers", "pdf.worker.min.mjs"]);
+        // The worker filename is intentionally stable for package consumers, so
+        // attach the PDF.js version to avoid reusing an incompatible cached worker
+        // after a dependency upgrade.
+        defaultWorkerUrl.searchParams.set("v", module.version);
+        const workerUrl = resolveAssetUrl(options.workerUrl, context.assetBaseUrl, defaultWorkerUrl);
+        const workerPort = new Worker(workerUrl, {
+            type: "module",
+            name: `pdfjs-${module.version}`,
+        });
+        const worker = new module.PDFWorker({ port: workerPort });
+        const loadingTask = module.getDocument({
+            data: data.slice(),
+            worker,
+            cMapUrl: directoryUrl(options.cMapUrl, context, assetRoot, "cmaps/"),
+            cMapPacked: true,
+            standardFontDataUrl: directoryUrl(options.standardFontDataUrl, context, assetRoot, "standard_fonts/"),
+            wasmUrl: directoryUrl(options.wasmUrl, context, assetRoot, "wasm/"),
+            iccUrl: directoryUrl(options.iccUrl, context, assetRoot, "iccs/"),
+            useWorkerFetch: true,
+            useWasm: true,
+            useSystemFonts: false,
+            disableFontFace: false,
+            isEvalSupported: false,
+            enableXfa: false,
+            stopAtErrors: false,
+            maxImageSize: context.limits.maxDecodedPixels,
+            canvasMaxAreaInBytes: context.limits.maxDecodedPixels * 4,
+        });
+        const onAbort = () => {
+            void loadingTask.destroy();
+            worker.destroy();
+            workerPort.terminate();
+        };
+        context.signal.addEventListener("abort", onAbort, { once: true });
+        try {
+            const document = await withTimeout(loadingTask.promise, context.limits.maxOperationMs, "PDF parsing");
+            if (context.signal.aborted)
+                throw abortError();
+            return new PdfJsBackend(module, document, worker, loadingTask, context.limits.maxDecodedPixels);
+        }
+        catch (error) {
+            await loadingTask.destroy().catch(() => undefined);
+            worker.destroy();
+            workerPort.terminate();
+            throw error;
+        }
+        finally {
+            context.signal.removeEventListener("abort", onAbort);
+        }
+    }
+    async renderPage(target, pageIndex, zoom, devicePixelRatio, signal) {
+        this.#assertOpen();
+        const page = await this.#page(pageIndex);
+        if (signal?.aborted)
+            throw abortError();
+        const viewport = page.getViewport({ scale: CSS_UNITS * zoom });
+        const dpr = Math.max(1, devicePixelRatio);
+        const width = Math.max(1, viewport.width);
+        const height = Math.max(1, viewport.height);
+        const pixels = Math.ceil(width * dpr) * Math.ceil(height * dpr);
+        if (!Number.isSafeInteger(pixels) || pixels > this.#maxPixels)
+            throw new ViewerError("resource-limit", "Rendered PDF page exceeds pixel limit", { details: { pixels, limit: this.#maxPixels } });
+        target.width = Math.max(1, Math.ceil(width * dpr));
+        target.height = Math.max(1, Math.ceil(height * dpr));
+        if ("style" in target) {
+            target.style.width = `${width}px`;
+            target.style.height = `${height}px`;
+        }
+        const context = target.getContext("2d");
+        if (!context)
+            throw new ViewerError("render-failed", "Canvas 2D context is unavailable");
+        const renderTask = page.render({
+            canvas: null,
+            canvasContext: context,
+            viewport,
+            transform: dpr === 1 ? undefined : [dpr, 0, 0, dpr, 0, 0],
+            background: "rgb(255,255,255)",
+            intent: "display",
+        });
+        const onAbort = () => renderTask.cancel(0);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+            await renderTask.promise;
+            if (signal?.aborted)
+                throw abortError();
+        }
+        catch (error) {
+            if (signal?.aborted ||
+                error instanceof this.#module.RenderingCancelledException ||
+                (error instanceof Error && error.name === "RenderingCancelledException"))
+                throw abortError();
+            throw new ViewerError("render-failed", "PDF.js page rendering failed", {
+                cause: error,
+            });
+        }
+        finally {
+            signal?.removeEventListener("abort", onAbort);
+        }
+    }
+    async pageSize(pageIndex, signal) {
+        this.#assertOpen();
+        const page = await raceAbort(this.#page(pageIndex), signal);
+        const viewport = page.getViewport({ scale: CSS_UNITS });
+        return { width: viewport.width, height: viewport.height };
+    }
+    async pageText(pageIndex, signal) {
+        this.#assertOpen();
+        const page = await this.#page(pageIndex);
+        if (signal?.aborted)
+            throw abortError();
+        const viewport = page.getViewport({ scale: CSS_UNITS });
+        const [content, annotations] = await Promise.all([
+            raceAbort(page.getTextContent(), signal),
+            raceAbort(page.getAnnotations({ intent: "display" }), signal),
+        ]);
+        const links = await this.#links(annotations, viewport, signal);
+        const runs = [];
+        let logicalOffset = 0;
+        for (const item of content.items) {
+            if (!("str" in item) || item.str.length === 0)
+                continue;
+            const style = content.styles[item.fontName] ?? {};
+            const run = textItemToRun(item, style, viewport, links, logicalOffset);
+            logicalOffset = run.logicalEnd ?? logicalOffset + item.str.length;
+            runs.push(run);
+        }
+        return runs;
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#pages.clear();
+        try {
+            await this.#document.cleanup();
+            await this.#loadingTask.destroy();
+        }
+        finally {
+            this.#worker.destroy();
+        }
+    }
+    #page(pageIndex) {
+        let page = this.#pages.get(pageIndex);
+        if (!page) {
+            page = this.#document.getPage(pageIndex + 1);
+            this.#pages.set(pageIndex, page);
+        }
+        return page;
+    }
+    async #links(annotations, viewport, signal) {
+        const result = [];
+        for (const annotation of annotations) {
+            if (annotation.subtype !== "Link" ||
+                !annotation.rect ||
+                annotation.rect.length < 4)
+                continue;
+            const target = await this.#linkTarget(annotation, signal);
+            if (!target)
+                continue;
+            const first = viewport.convertToViewportPoint(annotation.rect[0], annotation.rect[1]);
+            const second = viewport.convertToViewportPoint(annotation.rect[2], annotation.rect[3]);
+            result.push({
+                left: Math.min(first[0], second[0]),
+                top: Math.min(first[1], second[1]),
+                right: Math.max(first[0], second[0]),
+                bottom: Math.max(first[1], second[1]),
+                target,
+            });
+        }
+        return result;
+    }
+    async #linkTarget(annotation, signal) {
+        const external = safeExternalUrl(annotation.url ?? annotation.unsafeUrl);
+        if (external)
+            return external;
+        if (!annotation.dest)
+            return undefined;
+        const reference = typeof annotation.dest === "string"
+            ? await raceAbort(this.#document.getDestination(annotation.dest), signal)
+            : annotation.dest;
+        if (!reference || reference.length === 0)
+            return undefined;
+        let pageIndex;
+        try {
+            pageIndex = await raceAbort(this.#document.getPageIndex(reference[0]), signal);
+        }
+        catch {
+            // A malformed destination remains a typed internal link without a page.
+        }
+        return {
+            kind: "internal",
+            ref: typeof annotation.dest === "string" ? annotation.dest : "pdf-dest",
+            ...(pageIndex === undefined ? {} : { pageIndex }),
+        };
+    }
+    #assertOpen() {
+        if (this.#closed)
+            throw new ViewerError("lifecycle-error", "PDF backend is closed");
+    }
+}
+function textItemToRun(item, style, viewport, links, logicalStart) {
+    const transform = multiplyTransform(viewport.transform, item.transform);
+    let angle = Math.atan2(transform[1], transform[0]);
+    if (style.vertical)
+        angle += Math.PI / 2;
+    const fontHeight = Math.max(1, Math.hypot(transform[2], transform[3]));
+    const ascent = style.ascent !== undefined
+        ? style.ascent * fontHeight
+        : style.descent !== undefined
+            ? (1 + style.descent) * fontHeight
+            : fontHeight;
+    const left = transform[4] + fontHeight * Math.sin(angle) * (ascent / fontHeight);
+    const top = transform[5] - fontHeight * Math.cos(angle) * (ascent / fontHeight);
+    const width = Math.max(1, item.width * viewport.scale);
+    const height = Math.max(1, item.height * viewport.scale, fontHeight);
+    const hyperlink = links.find((link) => rectanglesOverlap({ left, top, right: left + width, bottom: top + height }, link))?.target;
+    const fontFamily = style.fontFamily ?? "sans-serif";
+    return {
+        text: item.str,
+        x: left,
+        y: top,
+        width,
+        height,
+        direction: item.dir === "rtl" ? "rtl" : "ltr",
+        fontFamily,
+        fontSize: fontHeight,
+        font: `${fontHeight}px ${fontFamily}`,
+        ...(Math.abs(angle) < 0.000_001
+            ? {}
+            : { transform: `rotate(${angle}rad)` }),
+        textLayer: "pdf",
+        coordinateWidth: viewport.width,
+        coordinateHeight: viewport.height,
+        logicalStart,
+        logicalEnd: logicalStart + item.str.length,
+        ...(hyperlink ? { hyperlink } : {}),
+    };
+}
+function multiplyTransform(first, second) {
+    return [
+        first[0] * second[0] + first[2] * second[1],
+        first[1] * second[0] + first[3] * second[1],
+        first[0] * second[2] + first[2] * second[3],
+        first[1] * second[2] + first[3] * second[3],
+        first[0] * second[4] + first[2] * second[5] + first[4],
+        first[1] * second[4] + first[3] * second[5] + first[5],
+    ];
+}
+function rectanglesOverlap(left, right) {
+    return !(left.right < right.left ||
+        left.left > right.right ||
+        left.bottom < right.top ||
+        left.top > right.bottom);
+}
+function safeExternalUrl(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        return ["http:", "https:", "mailto:", "tel:"].includes(url.protocol)
+            ? { kind: "external", url: url.href }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveAssetUrl(value, base, fallback) {
+    return value === undefined ? fallback : new URL(value, base);
+}
+function packageRelativeUrl(segments) {
+    // Keeping the path data-driven prevents application bundlers from treating
+    // the package-owned directory as an import to hash or inline. Hosts that
+    // bundle the facade should normally provide assetBaseUrl.
+    const moduleUrl = import.meta.url;
+    return new URL(segments.join("/"), moduleUrl);
+}
+function directoryUrl(value, context, assetRoot, directory) {
+    const url = resolveAssetUrl(value, context.assetBaseUrl, new URL(directory, assetRoot));
+    return url.href.endsWith("/") ? url.href : `${url.href}/`;
+}
+function raceAbort(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+function withTimeout(promise, timeoutMs, operation) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new ViewerError("resource-limit", `${operation} exceeded maxOperationMs`, { details: { timeoutMs } })), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timeout);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+}
+function isPasswordError(error, message) {
+    return ((error instanceof Error && error.name === "PasswordException") ||
+        /password|encrypted/i.test(message));
+}
+function assertPage(pageIndex, pageCount) {
+    if (!Number.isInteger(pageIndex) || pageIndex < 0 || pageIndex >= pageCount)
+        throw new ViewerError("render-failed", "PDF page index is out of range", {
+            details: { pageIndex, pageCount },
+        });
+}

package/dist/adapters/svg.d.ts

@@ -0,0 +1,17 @@
+import type { AdapterOpenContext, DocumentAdapter, DocumentInfo, RenderViewport, ViewerWarning } from "../contracts.js";
+interface SvgHandle {
+    readonly data: Uint8Array;
+    readonly warnings: readonly ViewerWarning[];
+}
+export declare class SvgDocumentAdapter implements DocumentAdapter<SvgHandle> {
+    readonly id = "svg";
+    readonly formats: readonly ["svg"];
+    open(data: Uint8Array, context: AdapterOpenContext): Promise<SvgHandle>;
+    getInfo(handle: SvgHandle): Promise<DocumentInfo>;
+    render(handle: SvgHandle, target: HTMLCanvasElement | OffscreenCanvas, viewport: RenderViewport, signal?: AbortSignal): Promise<void>;
+    getTextMap(): Promise<readonly []>;
+    close(): void;
+}
+export declare function sanitizeSvg(source: string): string;
+export declare function createSvgAdapter(): SvgDocumentAdapter;
+export {};

package/dist/adapters/svg.js

@@ -0,0 +1,123 @@
+import { abortError, ViewerError } from "../errors.js";
+import { drawEncodedImage } from "./bitmap.js";
+export class SvgDocumentAdapter {
+    id = "svg";
+    formats = ["svg"];
+    async open(data, context) {
+        if (context.signal.aborted)
+            throw abortError();
+        let source;
+        try {
+            source = new TextDecoder("utf-8", { fatal: true }).decode(data);
+        }
+        catch (error) {
+            throw new ViewerError("invalid-file", "SVG must be valid UTF-8", {
+                cause: error,
+            });
+        }
+        const sanitized = sanitizeSvg(source);
+        const changed = sanitized !== source;
+        return {
+            data: new TextEncoder().encode(sanitized),
+            warnings: changed
+                ? [
+                    {
+                        code: "external-resource-blocked",
+                        message: "Active SVG content or external resources were removed",
+                    },
+                ]
+                : [],
+        };
+    }
+    async getInfo(handle) {
+        return {
+            format: "svg",
+            unit: "image",
+            pageCount: 1,
+            warnings: handle.warnings,
+        };
+    }
+    async render(handle, target, viewport, signal) {
+        if (viewport.pageIndex !== 0)
+            throw new ViewerError("render-failed", "SVG page index is out of range");
+        if (signal?.aborted)
+            throw abortError();
+        await drawEncodedImage(handle.data, "image/svg+xml", target, {
+            dpr: viewport.devicePixelRatio,
+            scale: viewport.zoom,
+            ...(viewport.width === undefined ? {} : { cssWidth: viewport.width }),
+            ...(viewport.height === undefined ? {} : { cssHeight: viewport.height }),
+        });
+        if (signal?.aborted)
+            throw abortError();
+    }
+    async getTextMap() {
+        return [];
+    }
+    close() { }
+}
+export function sanitizeSvg(source) {
+    const withoutDoctype = source.replace(/<!DOCTYPE[\s\S]*?>/gi, "");
+    if (typeof DOMParser === "undefined")
+        return sanitizeSvgFallback(withoutDoctype);
+    const document = new DOMParser().parseFromString(withoutDoctype, "image/svg+xml");
+    if (document.querySelector("parsererror") ||
+        document.documentElement.localName !== "svg")
+        throw new ViewerError("invalid-file", "Malformed SVG document");
+    const blocked = new Set([
+        "script",
+        "style",
+        "foreignobject",
+        "iframe",
+        "object",
+        "embed",
+        "audio",
+        "video",
+        "canvas",
+    ]);
+    for (const element of [...document.querySelectorAll("*")]) {
+        if (blocked.has(element.localName.toLowerCase())) {
+            element.remove();
+            continue;
+        }
+        for (const attribute of [...element.attributes]) {
+            const name = attribute.name.toLowerCase();
+            const value = attribute.value.trim();
+            if (name.startsWith("on") ||
+                ((name === "href" || name === "xlink:href" || name === "src") &&
+                    !value.startsWith("#")) ||
+                (/url\s*\(/i.test(value) && !/url\s*\(\s*['"]?#/i.test(value)) ||
+                /expression\s*\(|@import/i.test(value))
+                element.removeAttribute(attribute.name);
+        }
+    }
+    return new XMLSerializer().serializeToString(document.documentElement);
+}
+export function createSvgAdapter() {
+    return new SvgDocumentAdapter();
+}
+function sanitizeSvgFallback(source) {
+    let result = source;
+    for (const tag of [
+        "script",
+        "style",
+        "foreignObject",
+        "iframe",
+        "object",
+        "embed",
+        "audio",
+        "video",
+        "canvas",
+    ]) {
+        const paired = new RegExp(`<${tag}\\b[\\s\\S]*?<\\/${tag}\\s*>`, "gi");
+        const single = new RegExp(`<${tag}\\b[^>]*\\/?>`, "gi");
+        result = result.replace(paired, "").replace(single, "");
+    }
+    result = result
+        .replace(/\s+on[\w:-]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "")
+        .replace(/\s+(?:href|xlink:href|src)\s*=\s*(?:"(?!#)[^"]*"|'(?!#)[^']*'|(?!#)[^\s>"']+)/gi, "")
+        .replace(/\s+style\s*=\s*(?:"[^"]*(?:url|expression|@import)[^"]*"|'[^']*(?:url|expression|@import)[^']*')/gi, "");
+    if (!/<svg(?:\s|>)/i.test(result))
+        throw new ViewerError("invalid-file", "Malformed SVG document");
+    return result;
+}

package/dist/assets/image/index.d.ts

@@ -0,0 +1,75 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Parsed, bounded multi-page TIFF document.
+ */
+export class TiffViewerDocument {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Decode all TIFF IFDs and retain compressed PNG pages.
+     *
+     * # Errors
+     *
+     * Returns an error for malformed/unsupported TIFF data or a pixel-limit breach.
+     */
+    constructor(data: Uint8Array, max_decoded_pixels: number);
+    /**
+     * Number of image directories/pages.
+     */
+    pageCount(): number;
+    /**
+     * Height of one page in pixels.
+     */
+    pageHeight(page_index: number): number;
+    /**
+     * Width of one page in pixels.
+     */
+    pageWidth(page_index: number): number;
+    /**
+     * Return a decoded page as PNG bytes.
+     *
+     * # Errors
+     *
+     * Returns an error when `page_index` is outside the document.
+     */
+    renderPagePng(page_index: number): Uint8Array;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_tiffviewerdocument_free: (a: number, b: number) => void;
+    readonly tiffviewerdocument_new: (a: number, b: number, c: number, d: number) => void;
+    readonly tiffviewerdocument_pageCount: (a: number) => number;
+    readonly tiffviewerdocument_pageHeight: (a: number, b: number) => number;
+    readonly tiffviewerdocument_pageWidth: (a: number, b: number) => number;
+    readonly tiffviewerdocument_renderPagePng: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;