web-doc 0.3.0

package/dist/detect.js

@@ -0,0 +1,290 @@
+import { ViewerError } from "./errors.js";
+const extensionFormats = {
+    docx: "docx",
+    docm: "docm",
+    xlsx: "xlsx",
+    xlsm: "xlsm",
+    pptx: "pptx",
+    pptm: "pptm",
+    ppsx: "ppsx",
+    doc: "doc",
+    xls: "xls",
+    ppt: "ppt",
+    pdf: "pdf",
+    csv: "csv",
+    tsv: "tsv",
+    png: "png",
+    jpg: "jpeg",
+    jpeg: "jpeg",
+    gif: "gif",
+    webp: "webp",
+    svg: "svg",
+    bmp: "bmp",
+    tif: "tiff",
+    tiff: "tiff",
+};
+const mimeFormats = {
+    "application/pdf": "pdf",
+    "application/msword": "doc",
+    "application/vnd.ms-excel": "xls",
+    "application/vnd.ms-powerpoint": "ppt",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    "application/vnd.ms-word.document.macroenabled.12": "docm",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    "application/vnd.ms-excel.sheet.macroenabled.12": "xlsm",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+    "application/vnd.ms-powerpoint.presentation.macroenabled.12": "pptm",
+    "application/vnd.openxmlformats-officedocument.presentationml.slideshow": "ppsx",
+    "text/csv": "csv",
+    "text/tab-separated-values": "tsv",
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "image/bmp": "bmp",
+    "image/tiff": "tiff",
+};
+export function detectFormat(data, hints = {}) {
+    if (isEncryptedOfficeContainer(data))
+        throw new ViewerError("encrypted-document", "Password-protected Office documents are not supported");
+    const hinted = hints.format ??
+        formatFromMime(hints.contentType) ??
+        formatFromFileName(hints.fileName ?? "");
+    const detected = detectByBytes(data, hinted);
+    if (!detected && hinted && ["csv", "tsv", "svg"].includes(hinted))
+        return { format: hinted, confidence: "hint", warnings: [] };
+    if (!detected)
+        throw new ViewerError("unsupported-format", "Unable to detect a supported document format", {
+            details: { fileName: hints.fileName, contentType: hints.contentType },
+        });
+    const format = preserveSubtype(detected, hinted);
+    const warnings = [];
+    if (hinted && !sameFamily(format, hinted))
+        warnings.push({
+            code: "format-hint-mismatch",
+            message: `Content is ${format}, but the supplied hint was ${hinted}; content wins`,
+            details: { detected: format, hinted },
+        });
+    return {
+        format,
+        confidence: detected === format ? "magic" : "container",
+        warnings,
+    };
+}
+function isEncryptedOfficeContainer(data) {
+    return (starts(data, [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]) &&
+        includesUtf16(data, "EncryptionInfo") &&
+        includesUtf16(data, "EncryptedPackage"));
+}
+export function formatFromFileName(fileName) {
+    const cleanName = fileName.split(/[?#]/, 1)[0] ?? fileName;
+    const dot = cleanName.lastIndexOf(".");
+    return dot < 0
+        ? undefined
+        : extensionFormats[cleanName.slice(dot + 1).toLowerCase()];
+}
+export function formatFromMime(contentType) {
+    return contentType
+        ? mimeFormats[contentType.split(";", 1)[0].trim().toLowerCase()]
+        : undefined;
+}
+export function sniffFormat(data) {
+    return detectByBytes(data);
+}
+function detectByBytes(data, hint) {
+    if (starts(data, [0x25, 0x50, 0x44, 0x46, 0x2d]))
+        return "pdf";
+    if (starts(data, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+        return "png";
+    if (starts(data, [0xff, 0xd8, 0xff]))
+        return "jpeg";
+    if (ascii(data, 0, 4) === "GIF8")
+        return "gif";
+    if (ascii(data, 0, 4) === "RIFF" && ascii(data, 8, 12) === "WEBP")
+        return "webp";
+    if (ascii(data, 0, 2) === "BM")
+        return "bmp";
+    if (starts(data, [0x49, 0x49, 0x2a, 0x00]) ||
+        starts(data, [0x4d, 0x4d, 0x00, 0x2a]))
+        return "tiff";
+    if (starts(data, [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]))
+        return detectOle(data) ?? legacyHint(hint);
+    if (starts(data, [0x50, 0x4b]))
+        return detectOoxml(data) ?? ooxmlHint(hint);
+    if (looksLikeSvg(data))
+        return "svg";
+    return undefined;
+}
+function detectOoxml(data) {
+    // Entry names from the central directory are the authoritative signal;
+    // scanning the whole buffer misreads compressed part data, where a random
+    // "xl/" or "word/" byte run is near-certain in a large media-heavy file.
+    const entryNames = readZipEntryNames(data);
+    if (entryNames)
+        return ooxmlFormatFromEntryNames(entryNames);
+    // No readable central directory (typically a truncated prefix passed to
+    // sniffFormat): keep the legacy substring scan as a best-effort fallback.
+    if (includesAscii(data, "word/"))
+        return "docx";
+    if (includesAscii(data, "xl/"))
+        return "xlsx";
+    if (includesAscii(data, "ppt/"))
+        return "pptx";
+    return undefined;
+}
+function ooxmlFormatFromEntryNames(entryNames) {
+    for (const name of entryNames) {
+        if (name === "word/document.xml")
+            return "docx";
+        if (name === "xl/workbook.xml")
+            return "xlsx";
+        if (name === "ppt/presentation.xml")
+            return "pptx";
+    }
+    if (entryNames.some((name) => name.startsWith("word/")))
+        return "docx";
+    if (entryNames.some((name) => name.startsWith("xl/")))
+        return "xlsx";
+    if (entryNames.some((name) => name.startsWith("ppt/")))
+        return "pptx";
+    return undefined;
+}
+const ZIP_EOCD_SIGNATURE = 0x06054b50;
+const ZIP_CENTRAL_HEADER_SIGNATURE = 0x02014b50;
+const ZIP_CENTRAL_DIGITAL_SIGNATURE = 0x05054b50;
+const ZIP_EOCD_MIN_BYTES = 22;
+// The end-of-central-directory record sits at most a 16-bit comment before
+// the end of the archive.
+const ZIP_EOCD_MAX_SCAN_BYTES = ZIP_EOCD_MIN_BYTES + 0xffff;
+const ZIP_CENTRAL_HEADER_MIN_BYTES = 46;
+/**
+ * Reads the archive's entry names from the central directory, or returns
+ * undefined when the directory cannot be read consistently (truncated input,
+ * zip64 markers, or corrupted records). Parsing is bounded by the record
+ * count and validated against the buffer on every step.
+ */
+function readZipEntryNames(data) {
+    if (data.byteLength < ZIP_EOCD_MIN_BYTES)
+        return undefined;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const stop = Math.max(0, view.byteLength - ZIP_EOCD_MAX_SCAN_BYTES);
+    let eocdOffset = -1;
+    for (let offset = view.byteLength - ZIP_EOCD_MIN_BYTES; offset >= stop; offset -= 1) {
+        if (view.getUint32(offset, true) !== ZIP_EOCD_SIGNATURE)
+            continue;
+        const commentLength = view.getUint16(offset + 20, true);
+        if (offset + ZIP_EOCD_MIN_BYTES + commentLength !== view.byteLength)
+            continue;
+        const diskNumber = view.getUint16(offset + 4, true);
+        const centralDisk = view.getUint16(offset + 6, true);
+        const entriesOnDisk = view.getUint16(offset + 8, true);
+        const entryCount = view.getUint16(offset + 10, true);
+        const centralSize = view.getUint32(offset + 12, true);
+        const centralOffset = view.getUint32(offset + 16, true);
+        if (diskNumber !== 0 ||
+            centralDisk !== 0 ||
+            entriesOnDisk !== entryCount ||
+            entryCount === 0xffff ||
+            centralSize === 0xffffffff ||
+            centralOffset === 0xffffffff ||
+            centralOffset + centralSize !== offset)
+            continue;
+        eocdOffset = offset;
+        break;
+    }
+    if (eocdOffset < 0)
+        return undefined;
+    const entryCount = view.getUint16(eocdOffset + 10, true);
+    let offset = view.getUint32(eocdOffset + 16, true);
+    // A zip64 archive stores 0xffffffff here; treat it as unreadable rather
+    // than guessing.
+    if (offset === 0xffffffff)
+        return undefined;
+    const decoder = new TextDecoder();
+    const names = [];
+    for (let index = 0; index < entryCount; index += 1) {
+        if (offset + ZIP_CENTRAL_HEADER_MIN_BYTES > eocdOffset)
+            return undefined;
+        if (view.getUint32(offset, true) !== ZIP_CENTRAL_HEADER_SIGNATURE)
+            return undefined;
+        const nameLength = view.getUint16(offset + 28, true);
+        const extraLength = view.getUint16(offset + 30, true);
+        const commentLength = view.getUint16(offset + 32, true);
+        const nameStart = offset + ZIP_CENTRAL_HEADER_MIN_BYTES;
+        const entryEnd = nameStart + nameLength + extraLength + commentLength;
+        if (entryEnd > eocdOffset)
+            return undefined;
+        names.push(decoder.decode(data.subarray(nameStart, nameStart + nameLength)));
+        offset = entryEnd;
+    }
+    if (offset === eocdOffset)
+        return names;
+    // A central-directory digital signature may follow the file headers.
+    if (offset + 6 <= eocdOffset &&
+        view.getUint32(offset, true) === ZIP_CENTRAL_DIGITAL_SIGNATURE &&
+        offset + 6 + view.getUint16(offset + 4, true) === eocdOffset)
+        return names;
+    return undefined;
+}
+function detectOle(data) {
+    if (includesUtf16(data, "WordDocument"))
+        return "doc";
+    if (includesUtf16(data, "Workbook") || includesUtf16(data, "Book"))
+        return "xls";
+    if (includesUtf16(data, "PowerPoint Document"))
+        return "ppt";
+    return undefined;
+}
+function preserveSubtype(detected, hinted) {
+    return hinted && sameFamily(detected, hinted) ? hinted : detected;
+}
+function sameFamily(a, b) {
+    return family(a) === family(b);
+}
+function family(format) {
+    if (["doc", "docx", "docm"].includes(format))
+        return "word";
+    if (["xls", "xlsx", "xlsm"].includes(format))
+        return "sheet";
+    if (["ppt", "pptx", "pptm", "ppsx"].includes(format))
+        return "slides";
+    return format;
+}
+function legacyHint(format) {
+    return format && ["doc", "xls", "ppt"].includes(format) ? format : undefined;
+}
+function ooxmlHint(format) {
+    return format &&
+        ["docx", "docm", "xlsx", "xlsm", "pptx", "pptm", "ppsx"].includes(format)
+        ? format
+        : undefined;
+}
+function looksLikeSvg(data) {
+    const prefix = new TextDecoder().decode(data.subarray(0, Math.min(data.byteLength, 4096)));
+    return /<(?:svg)(?:\s|>)/i.test(prefix.replace(/^\uFEFF/, ""));
+}
+function starts(data, signature) {
+    return signature.every((byte, index) => data[index] === byte);
+}
+function ascii(data, start, end) {
+    return String.fromCharCode(...data.subarray(start, end));
+}
+function includesAscii(data, text) {
+    return indexOf(data, new TextEncoder().encode(text)) >= 0;
+}
+function includesUtf16(data, text) {
+    const bytes = new Uint8Array(text.length * 2);
+    for (let index = 0; index < text.length; index += 1)
+        bytes[index * 2] = text.charCodeAt(index);
+    return indexOf(data, bytes) >= 0;
+}
+function indexOf(haystack, needle) {
+    outer: for (let offset = 0; offset <= haystack.length - needle.length; offset += 1) {
+        for (let index = 0; index < needle.length; index += 1)
+            if (haystack[offset + index] !== needle[index])
+                continue outer;
+        return offset;
+    }
+    return -1;
+}

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+import type { ViewerErrorCode, ViewerErrorData } from "./contracts.js";
+export declare class ViewerError extends Error implements ViewerErrorData {
+    readonly name: "ViewerError";
+    readonly code: ViewerErrorCode;
+    readonly details?: Readonly<Record<string, unknown>>;
+    constructor(code: ViewerErrorCode, message: string, options?: {
+        cause?: unknown;
+        details?: Readonly<Record<string, unknown>>;
+    });
+    toJSON(): ViewerErrorData;
+}
+export declare function abortError(message?: string): ViewerError;
+export declare function normalizeError(error: unknown, fallback?: ViewerErrorCode): ViewerError;
+export declare function errorFromData(data: ViewerErrorData): ViewerError;

package/dist/errors.js

@@ -0,0 +1,40 @@
+export class ViewerError extends Error {
+    name = "ViewerError";
+    code;
+    details;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.code = code;
+        if (options.details)
+            this.details = options.details;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            ...(this.details ? { details: this.details } : {}),
+        };
+    }
+}
+export function abortError(message = "Operation aborted") {
+    return new ViewerError("aborted", message);
+}
+export function normalizeError(error, fallback = "internal") {
+    if (error instanceof ViewerError)
+        return error;
+    if (isAbort(error))
+        return abortError();
+    return new ViewerError(fallback, error instanceof Error ? error.message : String(error), {
+        cause: error,
+    });
+}
+export function errorFromData(data) {
+    return new ViewerError(data.code, data.message, data.details ? { details: data.details } : {});
+}
+function isAbort(error) {
+    return ((typeof DOMException !== "undefined" &&
+        error instanceof DOMException &&
+        error.name === "AbortError") ||
+        (error instanceof Error && error.name === "AbortError"));
+}

package/dist/font-manifest.d.ts

@@ -0,0 +1,11 @@
+import type { FontScript } from "./contracts.js";
+export interface FallbackFontPack {
+    readonly id: string;
+    readonly scripts: readonly FontScript[];
+    readonly file: string;
+    readonly unicodeRange: string;
+    readonly family: string;
+    readonly license: "OFL-1.1";
+    readonly source: string;
+}
+export declare const fallbackFontPacks: readonly FallbackFontPack[];

package/dist/font-manifest.js

@@ -0,0 +1,31 @@
+const coreSource = "https://github.com/notofonts/noto-fonts/tree/ffebf8c1ee449e544955a7e813c54f9b73848eac";
+const cjkSource = "https://github.com/notofonts/noto-cjk/tree/f8d157532fbfaeda587e826d4cd5b21a49186f7c";
+export const fallbackFontPacks = Object.freeze([
+    pack("latin-cyrillic", ["latin", "cyrillic"], "noto-sans-latin-cyrillic.woff2", "U+0000-024F,U+0300-036F,U+0400-052F,U+1E00-1EFF"),
+    pack("arabic", ["arabic"], "noto-sans-arabic.woff2", "U+0600-06FF,U+0750-077F,U+08A0-08FF,U+FB50-FDFF,U+FE70-FEFF"),
+    pack("devanagari", ["devanagari"], "noto-sans-devanagari.woff2", "U+0900-097F,U+A8E0-A8FF"),
+    pack("bengali", ["bengali"], "noto-sans-bengali.woff2", "U+0980-09FF"),
+    pack("gurmukhi", ["gurmukhi"], "noto-sans-gurmukhi.woff2", "U+0A00-0A7F"),
+    pack("gujarati", ["gujarati"], "noto-sans-gujarati.woff2", "U+0A80-0AFF"),
+    pack("odia", ["odia"], "noto-sans-odia.woff2", "U+0B00-0B7F"),
+    pack("tamil", ["tamil"], "noto-sans-tamil.woff2", "U+0B80-0BFF"),
+    pack("telugu", ["telugu"], "noto-sans-telugu.woff2", "U+0C00-0C7F"),
+    pack("kannada", ["kannada"], "noto-sans-kannada.woff2", "U+0C80-0CFF"),
+    pack("malayalam", ["malayalam"], "noto-sans-malayalam.woff2", "U+0D00-0D7F"),
+    pack("cjk", ["cjk"], "noto-sans-cjk.woff2", "U+2E80-2FFF,U+3000-303F,U+31C0-31EF,U+3400-4DBF,U+4E00-9FFF,U+F900-FAFF"),
+    pack("japanese", ["japanese"], "noto-sans-japanese.woff2", "U+3040-30FF,U+31F0-31FF"),
+    pack("korean", ["korean"], "noto-sans-korean.woff2", "U+1100-11FF,U+3130-318F,U+AC00-D7AF"),
+]);
+function pack(id, scripts, file, unicodeRange) {
+    return Object.freeze({
+        id,
+        scripts: Object.freeze([...scripts]),
+        file,
+        unicodeRange,
+        family: "Zrimo Noto",
+        license: "OFL-1.1",
+        source: id === "cjk" || id === "japanese" || id === "korean"
+            ? cjkSource
+            : coreSource,
+    });
+}

package/dist/fonts/OFL-1.1.txt

@@ -0,0 +1,88 @@
+Copyright 2018 The Noto Project Authors (github.com/googlei18n/noto-fonts)
+
+This Font Software is licensed under the SIL Open Font License,
+Version 1.1.
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The fonts,
+including any derivative works, can be bundled, embedded, redistributed
+and/or sold with any software provided that any reserved names are not used
+by derivative works. The fonts and derivatives, however, cannot be released
+under any other type of license. The requirement for fonts to remain under
+this license does not apply to any document created using the fonts or their
+derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may include
+source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer or
+other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the Font Software, to use, study, copy, merge, embed, modify, redistribute,
+and sell modified and unmodified copies of the Font Software, subject to the
+following conditions:
+
+1) Neither the Font Software nor any of its individual components, in
+Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy contains
+the above copyright notice and this license. These can be included either as
+stand-alone text files, human-readable headers or in the appropriate
+machine-readable metadata fields within text or binary files as long as
+those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font Name(s)
+unless explicit written permission is granted by the corresponding Copyright
+Holder. This restriction only applies to the primary font name as presented
+to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any Modified
+Version, except to acknowledge the contribution(s) of the Copyright Holder(s)
+and the Author(s) or with their explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must be
+distributed entirely under this license, and must not be distributed under
+any other license. The requirement for fonts to remain under this license
+does not apply to any document created using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL,
+INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE
+THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
+

package/dist/fonts/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,10 @@
+# Packaged font notices
+
+The WOFF2 files in this directory are modified/subset builds of Noto Sans and Noto Sans CJK. They retain shaping tables and contain only the Unicode ranges recorded in `manifest.json`.
+
+- Noto Sans sources: `notofonts/noto-fonts` commit `ffebf8c1ee449e544955a7e813c54f9b73848eac`.
+- Noto Sans CJK sources: `notofonts/noto-cjk` commit `f8d157532fbfaeda587e826d4cd5b21a49186f7c`.
+- License: SIL Open Font License 1.1; see `OFL-1.1.txt`.
+- Modified font family used by the viewer: `Zrimo Noto`.
+
+No proprietary Microsoft font is included.

package/dist/fonts/manifest.json

@@ -0,0 +1,83 @@
+{
+  "schemaVersion": 1,
+  "family": "Zrimo Noto",
+  "generated": "2026-07-16",
+  "tooling": "fonttools pyftsubset with all layout features, then woff2_compress",
+  "license": "OFL-1.1",
+  "sources": {
+    "noto-fonts": "https://github.com/notofonts/noto-fonts/tree/ffebf8c1ee449e544955a7e813c54f9b73848eac",
+    "noto-cjk": "https://github.com/notofonts/noto-cjk/tree/f8d157532fbfaeda587e826d4cd5b21a49186f7c"
+  },
+  "files": [
+    {
+      "file": "noto-sans-latin-cyrillic.woff2",
+      "bytes": 79056,
+      "sha256": "505a16667b5224cb4e16d7d04e44bb55b5778d0b5a30039e780586a224cbea82"
+    },
+    {
+      "file": "noto-sans-arabic.woff2",
+      "bytes": 66380,
+      "sha256": "e7057aed431b120b3de7e1ebe2b8ed2131364a6e35756b5fee9a623923be1c08"
+    },
+    {
+      "file": "noto-sans-devanagari.woff2",
+      "bytes": 57128,
+      "sha256": "2fc2bc07b76e91770064afabe03b05247c6d69d392e9785417b0f94190f76975"
+    },
+    {
+      "file": "noto-sans-bengali.woff2",
+      "bytes": 60344,
+      "sha256": "d6b868dbeb063970ec0ffbb6d0158e92bdd1c9635c772d80c4bb0ab90ee9838b"
+    },
+    {
+      "file": "noto-sans-gurmukhi.woff2",
+      "bytes": 15612,
+      "sha256": "9fed08d6a9d79a1fdc78d52be6049ba8a0088275fc167d40fc9953b7d295b97a"
+    },
+    {
+      "file": "noto-sans-gujarati.woff2",
+      "bytes": 50560,
+      "sha256": "89a072974c4f04086385722eda3a29080bea10d5b5babd16c66ca36e51fa026c"
+    },
+    {
+      "file": "noto-sans-odia.woff2",
+      "bytes": 28572,
+      "sha256": "111f9eb26ac20096d2d733fdabe71eb7eadafe66315affec96e023211ab1c7d9"
+    },
+    {
+      "file": "noto-sans-tamil.woff2",
+      "bytes": 23100,
+      "sha256": "9b008f6fadf2279887f1721f03d98f9dfd0dfb4f235e1c7a815e05658384fffe"
+    },
+    {
+      "file": "noto-sans-telugu.woff2",
+      "bytes": 50908,
+      "sha256": "a55ff1e8040b4316d6d465abd0a0e56791ed2453adebec1db2b1d9e99f77b6c0"
+    },
+    {
+      "file": "noto-sans-kannada.woff2",
+      "bytes": 37304,
+      "sha256": "c0a028f65c258afcbd5d009741cb198860f0f0fbe7683f4d89f834cca565db3c"
+    },
+    {
+      "file": "noto-sans-malayalam.woff2",
+      "bytes": 34400,
+      "sha256": "565381e589a72ec76453edddc1f55458cfb93f7e6653f94b3651f3e2f2b5f9cc"
+    },
+    {
+      "file": "noto-sans-cjk.woff2",
+      "bytes": 9254856,
+      "sha256": "55cccb6ba3f0a2c06550b962edf45505dc818a09fe91af8267532bc1e9fb7097"
+    },
+    {
+      "file": "noto-sans-japanese.woff2",
+      "bytes": 89640,
+      "sha256": "96ff063a309fe8b598aee516ac304a1ae6cf4f4e40315b489c6a193b4fbbaed8"
+    },
+    {
+      "file": "noto-sans-korean.woff2",
+      "bytes": 1110144,
+      "sha256": "077e4178230f7cc0e7bd9a5ccdb5ad24f89692bb64f5d421b2095a69b4b9243a"
+    }
+  ]
+}

package/dist/fonts.d.ts

@@ -0,0 +1,20 @@
+import type { FontPolicy, FontRequest, FontScript, RegisteredFont, TextRun, ViewerFetch, ViewerWarning } from "./contracts.js";
+export interface FontEnvironment {
+    readonly FontFace?: typeof FontFace;
+    readonly fonts?: FontFaceSet;
+}
+export interface FontManagerOptions {
+    readonly policy?: FontPolicy;
+    readonly registered?: readonly RegisteredFont[];
+    readonly assetBaseUrl?: URL;
+    readonly fetch: ViewerFetch;
+    readonly environment?: FontEnvironment;
+}
+export declare class FontManager {
+    #private;
+    constructor(options: FontManagerOptions);
+    ensureRuns(runs: readonly TextRun[], reportWarning: (warning: ViewerWarning) => void, signal?: AbortSignal): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare function fontRequestsForRuns(runs: readonly TextRun[]): readonly FontRequest[];
+export declare function scriptForCodepoint(codepoint: number): FontScript;