web-doc 0.3.0

package/dist/fonts.js

@@ -0,0 +1,238 @@
+import { fallbackFontPacks } from "./font-manifest.js";
+const FALLBACK_FAMILY = "Zrimo Noto";
+export class FontManager {
+    #policy;
+    #registered;
+    #assetBaseUrl;
+    #fetch;
+    #environment;
+    #loads = new Map();
+    #faces = new Set();
+    #warned = new Set();
+    #destroyed = false;
+    constructor(options) {
+        this.#policy = { mode: options.policy?.mode ?? "auto", ...options.policy };
+        this.#registered = options.registered ?? [];
+        this.#assetBaseUrl = options.assetBaseUrl;
+        this.#fetch = options.fetch;
+        this.#environment = options.environment ?? {
+            FontFace: globalThis.FontFace,
+            fonts: globalThis.document?.fonts,
+        };
+    }
+    async ensureRuns(runs, reportWarning, signal) {
+        // PDF.js owns embedded/subset/standard-font loading for both its canvas and
+        // text layer. Resolving those generated families through the viewer's Noto
+        // policy would race the backend and can substitute the wrong metrics.
+        const requests = fontRequestsForRuns(runs.filter((run) => run.textLayer !== "pdf"));
+        await Promise.all(requests.map((request) => this.#ensureRequest(request, reportWarning, signal)));
+    }
+    async destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        await Promise.allSettled(this.#loads.values());
+        const fonts = this.#environment.fonts;
+        if (fonts)
+            for (const face of this.#faces)
+                fonts.delete(face);
+        this.#faces.clear();
+        this.#loads.clear();
+    }
+    async #ensureRequest(request, reportWarning, signal) {
+        if (this.#destroyed || signal?.aborted)
+            return;
+        const matching = this.#registered.filter((font) => (!font.scripts || font.scripts.includes(request.script)) &&
+            (!request.family || font.family === request.family));
+        if (matching.length > 0) {
+            const loaded = await Promise.all(matching.map((font) => this.#loadResolution(`registered:${font.family}:${request.script}:${font.weight ?? 400}:${font.style ?? "normal"}`, font, request, reportWarning, signal)));
+            if (loaded.some(Boolean))
+                return;
+        }
+        if (this.#hasSystemFont(request))
+            return;
+        if (this.#policy.mode === "offline") {
+            this.#warnUnavailable(request, reportWarning, "offline policy has no matching registered or system font");
+            return;
+        }
+        if (this.#policy.mode === "custom") {
+            const resolution = await this.#policy.resolver?.(request, signal ?? new AbortController().signal);
+            if (resolution &&
+                (await this.#loadResolution(`custom:${request.family ?? "fallback"}:${request.script}:${request.weight}:${request.style}`, resolution, request, reportWarning, signal)))
+                return;
+            this.#warnUnavailable(request, reportWarning, "custom resolver returned no usable font");
+            return;
+        }
+        const packs = fallbackFontPacks.filter((pack) => pack.scripts.includes(request.script));
+        const loaded = await Promise.all(packs.map((pack) => this.#loadPack(pack, request, reportWarning, signal)));
+        if (!loaded.some(Boolean))
+            this.#warnUnavailable(request, reportWarning, "packaged fallback could not be loaded");
+    }
+    #hasSystemFont(request) {
+        const fonts = this.#environment.fonts;
+        if (!fonts)
+            return false;
+        if (!request.family &&
+            request.script !== "latin" &&
+            request.script !== "cyrillic")
+            return false;
+        const family = request.family ? quoteFamily(request.family) : "system-ui";
+        return fonts.check(`${request.style} ${request.weight} 16px ${family}`, String.fromCodePoint(...request.codepoints.slice(0, 32)));
+    }
+    #loadPack(pack, request, reportWarning, signal) {
+        const base = this.#assetBaseUrl ?? new URL("./", import.meta.url);
+        return this.#loadResolution(`pack:${pack.id}`, {
+            family: pack.family,
+            source: new URL(`fonts/${pack.file}`, base),
+            weight: 400,
+            style: "normal",
+        }, request, reportWarning, signal, pack.unicodeRange);
+    }
+    #loadResolution(key, resolution, request, reportWarning, signal, unicodeRange) {
+        const cached = this.#loads.get(key);
+        if (cached)
+            return cached;
+        const loading = this.#createFace(resolution.family ?? FALLBACK_FAMILY, resolution.source, resolution.weight ?? request.weight, resolution.style ?? request.style, unicodeRange, signal).catch((error) => {
+            this.#warnOnce(`load:${key}`, reportWarning, {
+                code: "font-unavailable",
+                message: `Font ${resolution.family ?? FALLBACK_FAMILY} could not be loaded`,
+                details: {
+                    script: request.script,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            return false;
+        });
+        this.#loads.set(key, loading);
+        return loading;
+    }
+    async #createFace(family, source, weight, style, unicodeRange, signal) {
+        if (this.#destroyed || signal?.aborted)
+            return false;
+        const FontFaceConstructor = this.#environment.FontFace;
+        const fonts = this.#environment.fonts;
+        if (!FontFaceConstructor || !fonts)
+            return false;
+        const bytes = await fontBytes(source, this.#fetch, signal);
+        if (signal?.aborted)
+            return false;
+        const face = new FontFaceConstructor(family, bytes, {
+            weight: String(weight),
+            style,
+            ...(unicodeRange ? { unicodeRange } : {}),
+        });
+        this.#faces.add(face);
+        fonts.add(face);
+        try {
+            await face.load();
+            return true;
+        }
+        catch (error) {
+            fonts.delete(face);
+            this.#faces.delete(face);
+            throw error;
+        }
+    }
+    #warnUnavailable(request, reportWarning, reason) {
+        this.#warnOnce(`missing:${request.script}:${request.family ?? ""}`, reportWarning, {
+            code: "font-unavailable",
+            message: `No font was available for ${request.script} content`,
+            details: {
+                script: request.script,
+                requestedFamily: request.family,
+                substitution: FALLBACK_FAMILY,
+                reason,
+            },
+        });
+    }
+    #warnOnce(key, reportWarning, warning) {
+        if (this.#warned.has(key))
+            return;
+        this.#warned.add(key);
+        reportWarning(warning);
+    }
+}
+export function fontRequestsForRuns(runs) {
+    const requests = new Map();
+    const details = new Map();
+    for (const run of runs) {
+        for (const character of run.text) {
+            const codepoint = character.codePointAt(0);
+            const script = scriptForCodepoint(codepoint);
+            if (script === "unknown")
+                continue;
+            const weight = run.fontWeight ?? 400;
+            const style = run.fontStyle ?? "normal";
+            const key = `${run.fontFamily ?? ""}:${weight}:${style}:${script}`;
+            const points = requests.get(key) ?? new Set();
+            points.add(codepoint);
+            requests.set(key, points);
+            details.set(key, {
+                ...(run.fontFamily ? { family: run.fontFamily } : {}),
+                weight,
+                style,
+                script,
+            });
+        }
+    }
+    return [...requests].map(([key, codepoints]) => Object.freeze({
+        ...details.get(key),
+        codepoints: Object.freeze([...codepoints]),
+    }));
+}
+export function scriptForCodepoint(codepoint) {
+    if (inRanges(codepoint, [0x3040, 0x30ff, 0x31f0, 0x31ff]))
+        return "japanese";
+    if (inRanges(codepoint, [0x1100, 0x11ff, 0x3130, 0x318f, 0xac00, 0xd7af]))
+        return "korean";
+    if (inRanges(codepoint, [0x2e80, 0x2fff, 0x3400, 0x4dbf, 0x4e00, 0x9fff, 0xf900, 0xfaff]))
+        return "cjk";
+    if (inRanges(codepoint, [
+        0x0600, 0x06ff, 0x0750, 0x077f, 0x08a0, 0x08ff, 0xfb50, 0xfdff, 0xfe70,
+        0xfeff,
+    ]))
+        return "arabic";
+    if (inRanges(codepoint, [0x0900, 0x097f, 0xa8e0, 0xa8ff]))
+        return "devanagari";
+    if (inRanges(codepoint, [0x0980, 0x09ff]))
+        return "bengali";
+    if (inRanges(codepoint, [0x0a00, 0x0a7f]))
+        return "gurmukhi";
+    if (inRanges(codepoint, [0x0a80, 0x0aff]))
+        return "gujarati";
+    if (inRanges(codepoint, [0x0b00, 0x0b7f]))
+        return "odia";
+    if (inRanges(codepoint, [0x0b80, 0x0bff]))
+        return "tamil";
+    if (inRanges(codepoint, [0x0c00, 0x0c7f]))
+        return "telugu";
+    if (inRanges(codepoint, [0x0c80, 0x0cff]))
+        return "kannada";
+    if (inRanges(codepoint, [0x0d00, 0x0d7f]))
+        return "malayalam";
+    if (inRanges(codepoint, [0x0400, 0x052f]))
+        return "cyrillic";
+    if (inRanges(codepoint, [0x0000, 0x024f, 0x1e00, 0x1eff]) &&
+        /\p{Script=Latin}/u.test(String.fromCodePoint(codepoint)))
+        return "latin";
+    return "unknown";
+}
+async function fontBytes(source, fetch, signal) {
+    if (source instanceof ArrayBuffer)
+        return source.slice(0);
+    if (source instanceof Uint8Array)
+        return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+    const response = await fetch(source, signal ? { signal } : undefined);
+    if (!response.ok)
+        throw new Error(`Font request failed with HTTP ${response.status}`);
+    return response.arrayBuffer();
+}
+function inRanges(codepoint, ranges) {
+    for (let index = 0; index < ranges.length; index += 2)
+        if (codepoint >= ranges[index] && codepoint <= ranges[index + 1])
+            return true;
+    return false;
+}
+function quoteFamily(family) {
+    return `"${family.replaceAll('"', '\\"')}"`;
+}

package/dist/format.d.ts

@@ -0,0 +1 @@
+export { detectFormat, formatFromFileName, formatFromMime, sniffFormat, } from "./detect.js";

package/dist/format.js

@@ -0,0 +1 @@
+export { detectFormat, formatFromFileName, formatFromMime, sniffFormat, } from "./detect.js";

package/dist/headless.d.ts

@@ -0,0 +1,18 @@
+export * from "./contracts.js";
+export * from "./client.js";
+export * from "./viewer.js";
+export * from "./detect.js";
+export * from "./errors.js";
+export * from "./format.js";
+export * from "./limits.js";
+export * from "./interaction.js";
+export * from "./render-scheduler.js";
+export * from "./font-manifest.js";
+export * from "./fonts.js";
+export * from "./registry.js";
+export * from "./adapters/office.js";
+export * from "./adapters/pdf.js";
+export * from "./adapters/image.js";
+export * from "./adapters/csv.js";
+export * from "./adapters/csv-parser.js";
+export * from "./adapters/svg.js";

package/dist/headless.js

@@ -0,0 +1,18 @@
+export * from "./contracts.js";
+export * from "./client.js";
+export * from "./viewer.js";
+export * from "./detect.js";
+export * from "./errors.js";
+export * from "./format.js";
+export * from "./limits.js";
+export * from "./interaction.js";
+export * from "./render-scheduler.js";
+export * from "./font-manifest.js";
+export * from "./fonts.js";
+export * from "./registry.js";
+export * from "./adapters/office.js";
+export * from "./adapters/pdf.js";
+export * from "./adapters/image.js";
+export * from "./adapters/csv.js";
+export * from "./adapters/csv-parser.js";
+export * from "./adapters/svg.js";

package/dist/i18n.d.ts

@@ -0,0 +1,4 @@
+import type { ViewerLocale, ViewerTranslations } from "./contracts.js";
+export declare const englishTranslations: ViewerTranslations;
+export declare const russianTranslations: ViewerTranslations;
+export declare function resolveTranslations(locale: ViewerLocale | undefined, overrides: Partial<ViewerTranslations> | undefined): ViewerTranslations;

package/dist/i18n.js

@@ -0,0 +1,55 @@
+export const englishTranslations = Object.freeze({
+    previous: "Previous",
+    next: "Next",
+    page: "Page",
+    of: "of",
+    zoomIn: "Zoom in",
+    zoomOut: "Zoom out",
+    fitWidth: "Fit width",
+    fitPage: "Fit page",
+    search: "Search",
+    searchPlaceholder: "Search document",
+    matches: "matches",
+    thumbnails: "Thumbnails",
+    fullscreen: "Fullscreen",
+    exitFullscreen: "Exit fullscreen",
+    download: "Download original",
+    sheets: "Sheets",
+    selectedRange: "Selected range",
+    loading: "Loading…",
+    close: "Close",
+    noMatches: "No matches",
+});
+export const russianTranslations = Object.freeze({
+    previous: "Назад",
+    next: "Вперёд",
+    page: "Страница",
+    of: "из",
+    zoomIn: "Увеличить",
+    zoomOut: "Уменьшить",
+    fitWidth: "По ширине",
+    fitPage: "Вся страница",
+    search: "Поиск",
+    searchPlaceholder: "Найти в документе",
+    matches: "совпадений",
+    thumbnails: "Миниатюры",
+    fullscreen: "На весь экран",
+    exitFullscreen: "Выйти из полноэкранного режима",
+    download: "Скачать оригинал",
+    sheets: "Листы",
+    selectedRange: "Выбранный диапазон",
+    loading: "Загрузка…",
+    close: "Закрыть",
+    noMatches: "Совпадений нет",
+});
+const dictionaries = {
+    en: englishTranslations,
+    ru: russianTranslations,
+};
+export function resolveTranslations(locale, overrides) {
+    return Object.freeze({
+        ...englishTranslations,
+        ...(locale ? dictionaries[locale] : undefined),
+        ...overrides,
+    });
+}

package/dist/image-worker.d.ts

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

package/dist/image-worker.js

@@ -0,0 +1,41 @@
+const workerScope = self;
+let document;
+workerScope.onmessage = async (event) => {
+    const request = event.data;
+    try {
+        if (request.type === "open") {
+            if (!request.moduleUrl || !request.data || !request.maxPixels)
+                throw new Error("Invalid TIFF open request");
+            const module = (await import(
+            /* @vite-ignore */ request.moduleUrl));
+            await module.default();
+            document?.free();
+            document = new module.TiffViewerDocument(new Uint8Array(request.data), request.maxPixels);
+            const pages = Array.from({ length: document.pageCount() }, (_, pageIndex) => ({
+                width: document.pageWidth(pageIndex),
+                height: document.pageHeight(pageIndex),
+            }));
+            workerScope.postMessage({ id: request.id, ok: true, pages });
+        }
+        else if (request.type === "render") {
+            if (!document || request.pageIndex === undefined)
+                throw new Error("TIFF is not open");
+            const png = document.renderPagePng(request.pageIndex);
+            const data = png.slice().buffer;
+            workerScope.postMessage({ id: request.id, ok: true, data }, [data]);
+        }
+        else {
+            document?.free();
+            document = undefined;
+            workerScope.postMessage({ id: request.id, ok: true });
+        }
+    }
+    catch (error) {
+        workerScope.postMessage({
+            id: request.id,
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export * from "./contracts.js";
+export * from "./client.js";
+export * from "./detect.js";
+export * from "./errors.js";
+export * from "./format.js";
+export * from "./limits.js";
+export * from "./interaction.js";
+export * from "./render-scheduler.js";
+export * from "./i18n.js";
+export * from "./font-manifest.js";
+export * from "./fonts.js";
+export * from "./ui.js";
+export * from "./ui-styles.js";
+export * from "./registry.js";
+export * from "./viewer.js";
+export * from "./worker-client.js";
+export * from "./worker-adapter.js";
+export * from "./worker-endpoint.js";
+export * from "./worker-protocol.js";
+export * from "./adapters/office.js";
+export * from "./adapters/pdf.js";
+export * from "./adapters/image.js";
+export * from "./adapters/csv.js";
+export * from "./adapters/csv-parser.js";
+export * from "./adapters/svg.js";
+import type { ViewerClientOptions, ViewerOptions } from "./contracts.js";
+export declare function createViewer(options?: ViewerOptions, clientOptions?: ViewerClientOptions): import("./viewer.js").DocumentViewer;

package/dist/index.js

@@ -0,0 +1,29 @@
+export * from "./contracts.js";
+export * from "./client.js";
+export * from "./detect.js";
+export * from "./errors.js";
+export * from "./format.js";
+export * from "./limits.js";
+export * from "./interaction.js";
+export * from "./render-scheduler.js";
+export * from "./i18n.js";
+export * from "./font-manifest.js";
+export * from "./fonts.js";
+export * from "./ui.js";
+export * from "./ui-styles.js";
+export * from "./registry.js";
+export * from "./viewer.js";
+export * from "./worker-client.js";
+export * from "./worker-adapter.js";
+export * from "./worker-endpoint.js";
+export * from "./worker-protocol.js";
+export * from "./adapters/office.js";
+export * from "./adapters/pdf.js";
+export * from "./adapters/image.js";
+export * from "./adapters/csv.js";
+export * from "./adapters/csv-parser.js";
+export * from "./adapters/svg.js";
+import { ViewerClient } from "./client.js";
+export function createViewer(options = {}, clientOptions = {}) {
+    return ViewerClient.create(clientOptions).createViewer(options);
+}

package/dist/interaction.d.ts

@@ -0,0 +1,24 @@
+import type { CellRange, SearchMatch } from "./contracts.js";
+export interface VirtualRange {
+    readonly start: number;
+    readonly end: number;
+}
+export declare function visibleRange(scrollOffset: number, viewportExtent: number, itemExtent: number, itemCount: number, overscan?: number): VirtualRange;
+export declare function normalizeCellRange(range: CellRange): CellRange;
+export declare function findNormalizedMatches(text: string, query: string, pageIndex: number, caseSensitive?: boolean): readonly SearchMatch[];
+export declare function normalizeSearchText(text: string, caseSensitive?: boolean): string;
+/** Clamp a UTF-16 DOM offset to a grapheme boundary for native selection UI. */
+export declare function snapGraphemeOffset(text: string, offset: number, edge: "start" | "end"): number;
+export declare function cellRangeToTsv(range: CellRange, cells: ReadonlyMap<string, string>): string;
+export declare function cellRangesToTsv(ranges: readonly CellRange[], cells: ReadonlyMap<string, string>): string;
+export declare class LruMap<K, V> {
+    #private;
+    constructor(capacity: number);
+    get size(): number;
+    get(key: K): V | undefined;
+    set(key: K, value: V): {
+        key: K;
+        value: V;
+    } | undefined;
+    clear(): void;
+}

package/dist/interaction.js

@@ -0,0 +1,183 @@
+export function visibleRange(scrollOffset, viewportExtent, itemExtent, itemCount, overscan = 1) {
+    if (itemCount <= 0 || itemExtent <= 0)
+        return { start: 0, end: 0 };
+    const first = Math.floor(Math.max(0, scrollOffset) / itemExtent);
+    const last = Math.ceil((Math.max(0, scrollOffset) + Math.max(0, viewportExtent)) / itemExtent);
+    return {
+        start: Math.max(0, first - Math.max(0, Math.trunc(overscan))),
+        end: Math.min(itemCount, last + Math.max(0, Math.trunc(overscan))),
+    };
+}
+export function normalizeCellRange(range) {
+    return {
+        sheetIndex: Math.max(0, Math.trunc(range.sheetIndex)),
+        startRow: Math.max(1, Math.min(range.startRow, range.endRow)),
+        startColumn: Math.max(1, Math.min(range.startColumn, range.endColumn)),
+        endRow: Math.max(1, Math.max(range.startRow, range.endRow)),
+        endColumn: Math.max(1, Math.max(range.startColumn, range.endColumn)),
+    };
+}
+export function findNormalizedMatches(text, query, pageIndex, caseSensitive = false) {
+    const haystack = normalizeWithMap(text, caseSensitive);
+    const needle = normalizeSearchText(query, caseSensitive);
+    if (!needle)
+        return [];
+    const matches = [];
+    let offset = 0;
+    while (offset <= haystack.text.length - needle.length) {
+        const found = haystack.text.indexOf(needle, offset);
+        if (found < 0)
+            break;
+        const last = found + needle.length - 1;
+        const start = haystack.starts[found] ?? 0;
+        const end = haystack.ends[last] ?? start;
+        matches.push({
+            pageIndex,
+            start,
+            end,
+            text: text.slice(start, end),
+        });
+        offset = found + Math.max(1, needle.length);
+    }
+    return matches;
+}
+export function normalizeSearchText(text, caseSensitive = false) {
+    const normalized = text.normalize("NFKC");
+    return caseSensitive ? normalized : unicodeCaseFold(normalized);
+}
+/** Clamp a UTF-16 DOM offset to a grapheme boundary for native selection UI. */
+export function snapGraphemeOffset(text, offset, edge) {
+    const safeOffset = Math.max(0, Math.min(text.length, Math.trunc(offset)));
+    for (const segment of graphemeSegments(text)) {
+        if (safeOffset === segment.start || safeOffset === segment.end)
+            return safeOffset;
+        if (safeOffset > segment.start && safeOffset < segment.end)
+            return edge === "start" ? segment.start : segment.end;
+    }
+    return safeOffset;
+}
+export function cellRangeToTsv(range, cells) {
+    const normalized = normalizeCellRange(range);
+    const rows = [];
+    for (let row = normalized.startRow; row <= normalized.endRow; row += 1) {
+        const values = [];
+        for (let column = normalized.startColumn; column <= normalized.endColumn; column += 1)
+            values.push(escapeTsv(cells.get(`${row}:${column}`) ?? ""));
+        rows.push(values.join("\t"));
+    }
+    return rows.join("\n");
+}
+export function cellRangesToTsv(ranges, cells) {
+    if (ranges.length === 0)
+        return "";
+    if (ranges.length === 1)
+        return cellRangeToTsv(ranges[0], cells);
+    const rows = new Map();
+    for (const rawRange of ranges) {
+        const range = normalizeCellRange(rawRange);
+        for (let row = range.startRow; row <= range.endRow; row += 1) {
+            const intervals = rows.get(row) ?? [];
+            intervals.push({ start: range.startColumn, end: range.endColumn });
+            rows.set(row, intervals);
+        }
+    }
+    const output = [];
+    for (const [row, intervals] of [...rows].sort(([left], [right]) => left - right)) {
+        const selected = mergeIntervals(intervals);
+        const start = selected[0].start;
+        const end = selected[selected.length - 1].end;
+        const values = [];
+        for (let column = start; column <= end; column += 1) {
+            const included = selected.some((interval) => column >= interval.start && column <= interval.end);
+            values.push(included ? escapeTsv(cells.get(`${row}:${column}`) ?? "") : "");
+        }
+        output.push(values.join("\t"));
+    }
+    return output.join("\n");
+}
+export class LruMap {
+    #values = new Map();
+    #capacity;
+    constructor(capacity) {
+        this.#capacity = Math.max(1, Math.trunc(capacity));
+    }
+    get size() {
+        return this.#values.size;
+    }
+    get(key) {
+        const value = this.#values.get(key);
+        if (value === undefined)
+            return undefined;
+        this.#values.delete(key);
+        this.#values.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        if (this.#values.has(key))
+            this.#values.delete(key);
+        this.#values.set(key, value);
+        if (this.#values.size <= this.#capacity)
+            return undefined;
+        const oldest = this.#values.entries().next().value;
+        this.#values.delete(oldest[0]);
+        return { key: oldest[0], value: oldest[1] };
+    }
+    clear() {
+        this.#values.clear();
+    }
+}
+function normalizeWithMap(text, caseSensitive) {
+    const output = [];
+    const starts = [];
+    const ends = [];
+    const segments = graphemeSegments(text);
+    for (const segment of segments) {
+        const normalized = normalizeSearchText(segment.value, caseSensitive);
+        output.push(normalized);
+        for (let index = 0; index < normalized.length; index += 1) {
+            starts.push(segment.start);
+            ends.push(segment.end);
+        }
+    }
+    return { text: output.join(""), starts, ends };
+}
+function graphemeSegments(text) {
+    if (typeof Intl.Segmenter === "function") {
+        const segmenter = new Intl.Segmenter(undefined, {
+            granularity: "grapheme",
+        });
+        return [...segmenter.segment(text)].map((segment) => ({
+            value: segment.segment,
+            start: segment.index,
+            end: segment.index + segment.segment.length,
+        }));
+    }
+    const result = [];
+    let offset = 0;
+    for (const value of text) {
+        result.push({ value, start: offset, end: offset + value.length });
+        offset += value.length;
+    }
+    return result;
+}
+function unicodeCaseFold(text) {
+    return text
+        .toLocaleLowerCase("und")
+        .replaceAll("ß", "ss")
+        .replaceAll("ς", "σ");
+}
+function escapeTsv(value) {
+    return /[\t\n\r"]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
+}
+function mergeIntervals(intervals) {
+    const sorted = [...intervals].sort((left, right) => left.start - right.start);
+    const merged = [];
+    for (const interval of sorted) {
+        const previous = merged.at(-1);
+        if (previous && interval.start <= previous.end + 1)
+            previous.end = Math.max(previous.end, interval.end);
+        else
+            merged.push({ ...interval });
+    }
+    return merged;
+}

package/dist/legacy-converter-worker.d.ts

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

package/dist/legacy-converter-worker.js

@@ -0,0 +1,19 @@
+const workerScope = self;
+workerScope.onmessage = async (event) => {
+    try {
+        const module = (await import(
+        /* @vite-ignore */ event.data.moduleUrl));
+        await module.default();
+        const output = module.convertLegacyToOoxml(new Uint8Array(event.data.data), event.data.format);
+        const data = output.slice().buffer;
+        workerScope.postMessage({ ok: true, data }, [data]);
+    }
+    catch (error) {
+        workerScope.postMessage({
+            ok: false,
+            data: new ArrayBuffer(0),
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+};
+export {};