omni-viewer-core 0.1.0

package/dist/viewers/video/styles.js

@@ -0,0 +1,79 @@
+// Video viewer stylesheet. Single source for both delivery forms (DESIGN.md
+// §6): the build emits dist/styles/video.css from this constant, and the
+// renderer injects it into the shadow root. Only --omni-* tokens (with
+// fallbacks) — never --vscode-* or platform variables.
+export const videoViewerCss = `
+/* Reverse-contamination guard (DESIGN.md §6). */
+.omni-viewer--video {
+    all: initial;
+}
+.omni-viewer--video :where(button, select, option, input, label, video) {
+    all: revert;
+}
+
+:host, .omni-viewer--video {
+    display: block;
+    height: 100%;
+    box-sizing: border-box;
+    color: var(--omni-fg, #d4d4d4);
+    background: var(--omni-bg, #1e1e1e);
+    font-family: var(--omni-font, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif);
+    font-size: var(--omni-font-size, 13px);
+}
+
+.omni-video { display: flex; flex-direction: column; gap: 12px; box-sizing: border-box; height: 100%; padding: 16px; }
+.omni-video * { box-sizing: border-box; }
+
+.omni-video__header { display: flex; justify-content: space-between; align-items: baseline; gap: 16px; }
+.omni-video__title { font-size: 16px; font-weight: 650; overflow-wrap: anywhere; }
+.omni-video__meta { color: var(--omni-muted, #9d9d9d); white-space: nowrap; }
+
+.omni-video__info { display: flex; gap: 18px; padding: 6px 10px; border: 1px solid var(--omni-border, #444); border-radius: 6px; background: var(--omni-panel-bg, #252526); }
+.omni-video__info[hidden] { display: none; }
+.omni-video__info-item { display: flex; flex-direction: column; align-items: center; gap: 2px; }
+.omni-video__info-label { font-size: 10px; opacity: 0.7; }
+.omni-video__info-value { font-family: var(--omni-mono, ui-monospace, Menlo, monospace); font-weight: 500; }
+
+.omni-video__controls { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; padding: 6px; border: 1px solid var(--omni-border, #444); border-radius: 8px; background: var(--omni-panel-bg, #252526); }
+.omni-video__group { display: flex; align-items: center; gap: 5px; }
+.omni-video__group-label { font-size: 12px; color: var(--omni-muted, #9d9d9d); }
+
+.omni-video__btn {
+    background: var(--omni-accent, #0e639c); color: var(--omni-accent-fg, #fff);
+    border: none; padding: 5px 11px; border-radius: 4px; cursor: pointer; font-size: 12px; font-family: inherit;
+}
+.omni-video__btn:hover { background: var(--omni-accent-hover, #1177bb); }
+.omni-video__btn:disabled { opacity: 0.5; cursor: not-allowed; }
+
+.omni-video__select {
+    background: var(--omni-input-bg, #3c3c3c); color: var(--omni-fg, #d4d4d4);
+    border: 1px solid var(--omni-border, #444); padding: 4px 8px; border-radius: 4px; font-size: 12px; font-family: inherit;
+}
+.omni-video__zoom-label { font-family: var(--omni-mono, ui-monospace, Menlo, monospace); font-size: 12px; min-width: 42px; text-align: center; color: var(--omni-muted, #9d9d9d); }
+
+.omni-video__progress-row { display: flex; align-items: center; gap: 10px; padding: 4px 6px; border: 1px solid var(--omni-border, #444); border-radius: 8px; background: var(--omni-panel-bg, #252526); }
+.omni-video__time { font-family: var(--omni-mono, ui-monospace, Menlo, monospace); font-size: 12px; min-width: 52px; text-align: center; }
+.omni-video__bar { flex: 1; height: 8px; background: var(--omni-input-bg, #3c3c3c); border-radius: 4px; cursor: pointer; position: relative; }
+.omni-video__bar:hover, .omni-video__bar--dragging { height: 12px; }
+.omni-video__bar-filled { height: 100%; width: 0%; background: var(--omni-accent, #0e639c); border-radius: 4px; pointer-events: none; position: relative; }
+.omni-video__bar-handle {
+    width: 14px; height: 14px; background: var(--omni-accent-fg, #fff); border: 2px solid var(--omni-accent, #0e639c);
+    border-radius: 50%; position: absolute; right: -7px; top: 50%; transform: translateY(-50%);
+    opacity: 0; transition: opacity 0.15s; pointer-events: none;
+}
+.omni-video__bar:hover .omni-video__bar-handle, .omni-video__bar--dragging .omni-video__bar-handle { opacity: 1; }
+
+.omni-video__stage {
+    flex: 1; min-height: 240px; display: flex; justify-content: center; align-items: center;
+    border: 1px solid var(--omni-border, #444); border-radius: 8px; background: #000; overflow: hidden; position: relative;
+}
+.omni-video__stage--zoomed { overflow: auto; }
+.omni-video__wrapper { transition: transform 0.2s ease; transform-origin: center center; }
+.omni-video video { display: block; max-width: 100%; max-height: 70vh; background: #000; }
+
+.omni-video__warning {
+    padding: 10px 12px; border: 1px solid #b98b2f; border-radius: 7px;
+    background: #3b2d10; color: #ffd98a; white-space: pre-wrap;
+}
+.omni-video__warning[hidden] { display: none; }
+`;

package/dist/viewers/word/controller.d.ts

@@ -0,0 +1,19 @@
+export interface WordViewState {
+    zoom: number;
+}
+export type WordAction = {
+    type: 'zoom-in';
+} | {
+    type: 'zoom-out';
+} | {
+    type: 'reset-zoom';
+};
+export interface WordController {
+    readonly state: WordViewState;
+    dispatch(action: WordAction): void;
+    subscribe(listener: (state: WordViewState) => void): () => void;
+}
+export declare const WORD_MIN_ZOOM = 0.25;
+export declare const WORD_MAX_ZOOM = 2.5;
+export declare const WORD_ZOOM_STEP = 0.1;
+export declare function createWordController(): WordController;

package/dist/viewers/word/controller.js

@@ -0,0 +1,22 @@
+export const WORD_MIN_ZOOM = 0.25;
+export const WORD_MAX_ZOOM = 2.5;
+export const WORD_ZOOM_STEP = 0.1;
+export function createWordController() {
+    let zoom = 1;
+    const listeners = new Set();
+    const snapshot = () => ({ zoom });
+    const emit = () => listeners.forEach((listener) => listener(snapshot()));
+    return {
+        get state() { return snapshot(); },
+        dispatch(action) {
+            if (action.type === 'zoom-in')
+                zoom = Math.min(WORD_MAX_ZOOM, Math.round((zoom + WORD_ZOOM_STEP) * 100) / 100);
+            if (action.type === 'zoom-out')
+                zoom = Math.max(WORD_MIN_ZOOM, Math.round((zoom - WORD_ZOOM_STEP) * 100) / 100);
+            if (action.type === 'reset-zoom')
+                zoom = 1;
+            emit();
+        },
+        subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); }
+    };
+}

package/dist/viewers/word/docx-preprocess.d.ts

@@ -0,0 +1,63 @@
+export interface ZipEntry {
+    dir: boolean;
+    async(type: 'string'): Promise<string>;
+    async(type: 'uint8array'): Promise<Uint8Array>;
+}
+export interface ZipArchive {
+    file(path: string): ZipEntry | null;
+    file(path: string, data: string): ZipArchive;
+    forEach(callback: (path: string, entry: ZipEntry) => void): void;
+    generateAsync(options: {
+        type: 'uint8array';
+    }): Promise<Uint8Array>;
+}
+export interface ZipModule {
+    loadAsync(data: Uint8Array): Promise<ZipArchive>;
+}
+export interface SheetModule {
+    read(data: Uint8Array, options: {
+        type: 'array';
+    }): {
+        SheetNames: string[];
+        Sheets: Record<string, unknown>;
+    };
+    utils: {
+        sheet_to_json(sheet: unknown, options: {
+            header: 1;
+            blankrows: false;
+        }): unknown[][];
+    };
+}
+export interface ChartModel {
+    title: string;
+    categories: string[];
+    series: Array<{
+        name: string;
+        color: string;
+        values: number[];
+    }>;
+}
+export type DocxPlaceholder = {
+    token: string;
+    kind: 'chart';
+    chart: ChartModel;
+} | {
+    token: string;
+    kind: 'sheet';
+    title: string;
+    rows: string[][];
+};
+export interface DocxPreprocessResult {
+    data: Uint8Array;
+    placeholders: DocxPlaceholder[];
+}
+/** Default cap on declared/observed uncompressed bytes (input is already
+ *  capped at 50 MB by the viewer; this bounds the expansion ratio). */
+export declare const DOCX_MAX_DECOMPRESSED_BYTES: number;
+/** Thrown before any inflate when the archive declares more data than the cap
+ *  — the word viewer maps it to `diag.word.decompression-limit`. */
+export declare class DocxDecompressionLimitError extends Error {
+    constructor();
+}
+export declare function preprocessDocx(data: Uint8Array, zipModule: ZipModule, sheetModule?: SheetModule, maxDecompressedBytes?: number): Promise<DocxPreprocessResult>;
+export declare function parseChart(xml: string): ChartModel | null;

package/dist/viewers/word/docx-preprocess.js

@@ -0,0 +1,136 @@
+import { declaredZipUncompressedBytes } from '../../parsers/zip-scan.js';
+/** Default cap on declared/observed uncompressed bytes (input is already
+ *  capped at 50 MB by the viewer; this bounds the expansion ratio). */
+export const DOCX_MAX_DECOMPRESSED_BYTES = 1024 * 1024 * 1024;
+/** Thrown before any inflate when the archive declares more data than the cap
+ *  — the word viewer maps it to `diag.word.decompression-limit`. */
+export class DocxDecompressionLimitError extends Error {
+    constructor() { super('DOCX declares more uncompressed data than the supported limit'); this.name = 'DocxDecompressionLimitError'; }
+}
+const entities = (value) => value.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, '&');
+const resolvePath = (base, target) => { const stack = base.split('/').slice(0, -1); for (const part of target.split('/')) {
+    if (!part || part === '.')
+        continue;
+    if (part === '..')
+        stack.pop();
+    else
+        stack.push(part);
+} return stack.join('/'); };
+const attrs = (xml) => new Map([...xml.matchAll(/([\w:]+)="([^"]*)"/g)].map((match) => [match[1] ?? '', match[2] ?? '']));
+export async function preprocessDocx(data, zipModule, sheetModule, maxDecompressedBytes = DOCX_MAX_DECOMPRESSED_BYTES) {
+    // Zip-bomb guard: reject on the central directory's declared total before
+    // any inflate, then keep a running budget over what we actually extract
+    // (headers can lie about per-entry sizes).
+    const declared = declaredZipUncompressedBytes(data);
+    if (declared !== null && declared > maxDecompressedBytes)
+        throw new DocxDecompressionLimitError();
+    let budget = maxDecompressedBytes;
+    const spend = (value) => { budget -= value.length; if (budget < 0)
+        throw new DocxDecompressionLimitError(); return value; };
+    const zip = await zipModule.loadAsync(data);
+    const placeholders = [];
+    let changed = false;
+    const xmlFiles = [];
+    zip.forEach((path, entry) => { if (!entry.dir && /^word\/.*\.xml$/i.test(path))
+        xmlFiles.push(path); });
+    for (const path of xmlFiles) {
+        const entry = zip.file(path);
+        if (!entry)
+            continue;
+        const xml = spend(await entry.async('string'));
+        const normalized = xml.replace(/<mc:AlternateContent[\s\S]*?<mc:Fallback>([\s\S]*?)<\/mc:Fallback>[\s\S]*?<\/mc:AlternateContent>/g, '$1');
+        if (normalized !== xml) {
+            zip.file(path, normalized);
+            changed = true;
+        }
+    }
+    const documentEntry = zip.file('word/document.xml'), relsEntry = zip.file('word/_rels/document.xml.rels');
+    if (!documentEntry || !relsEntry)
+        return { data, placeholders };
+    let documentXml = spend(await documentEntry.async('string'));
+    const relsXml = spend(await relsEntry.async('string'));
+    const relationships = new Map();
+    for (const match of relsXml.matchAll(/<Relationship\b[^>]*\/?\s*>/g)) {
+        const values = attrs(match[0]);
+        const id = values.get('Id'), target = values.get('Target');
+        if (id && target)
+            relationships.set(id, { target: resolvePath('word/document.xml', target), type: values.get('Type') ?? '' });
+    }
+    let index = 0;
+    const chartRegex = /<w:drawing[\s\S]*?<c:chart\b[^>]*r:id="([^"]+)"[\s\S]*?<\/w:drawing>/g;
+    let output = '', cursor = 0;
+    for (const match of documentXml.matchAll(chartRegex)) {
+        const start = match.index ?? 0;
+        output += documentXml.slice(cursor, start);
+        cursor = start + match[0].length;
+        const relation = relationships.get(match[1] ?? '');
+        const entry = relation ? zip.file(relation.target) : null;
+        const chart = entry ? parseChart(spend(await entry.async('string'))) : null;
+        if (!chart) {
+            output += match[0];
+            continue;
+        }
+        const token = `__OMNI_WORD_CHART_${index++}__`;
+        placeholders.push({ token, kind: 'chart', chart });
+        output += `<w:r><w:t xml:space="preserve">${token}</w:t></w:r>`;
+        changed = true;
+    }
+    documentXml = output + documentXml.slice(cursor);
+    if (sheetModule) {
+        const objectRegex = /<w:object[\s\S]*?<o:OLEObject\b[^>]*r:id="([^"]+)"[\s\S]*?<\/w:object>/g;
+        output = '';
+        cursor = 0;
+        for (const match of documentXml.matchAll(objectRegex)) {
+            const start = match.index ?? 0;
+            output += documentXml.slice(cursor, start);
+            cursor = start + match[0].length;
+            const relation = relationships.get(match[1] ?? '');
+            const entry = relation ? zip.file(relation.target) : null;
+            if (!entry || !/package|oleObject/i.test(relation?.type ?? '')) {
+                output += match[0];
+                continue;
+            }
+            try {
+                const bytes = spend(await entry.async('uint8array'));
+                if ((declaredZipUncompressedBytes(bytes) ?? 0) > budget) {
+                    output += match[0];
+                    continue;
+                }
+                const workbook = sheetModule.read(bytes, { type: 'array' });
+                const name = workbook.SheetNames[0];
+                const sheet = name ? workbook.Sheets[name] : undefined;
+                if (!name || !sheet) {
+                    output += match[0];
+                    continue;
+                }
+                const rows = sheetModule.utils.sheet_to_json(sheet, { header: 1, blankrows: false }).slice(0, 10).map((row) => row.slice(0, 10).map((cell) => String(cell ?? '')));
+                const token = `__OMNI_WORD_SHEET_${index++}__`;
+                placeholders.push({ token, kind: 'sheet', title: name, rows });
+                output += `<w:r><w:t xml:space="preserve">${token}</w:t></w:r>`;
+                changed = true;
+            }
+            catch {
+                output += match[0];
+            }
+        }
+        documentXml = output + documentXml.slice(cursor);
+    }
+    if (changed) {
+        zip.file('word/document.xml', documentXml);
+        return { data: await zip.generateAsync({ type: 'uint8array' }), placeholders };
+    }
+    return { data, placeholders };
+}
+export function parseChart(xml) {
+    const seriesXml = [...xml.matchAll(/<c:ser>([\s\S]*?)<\/c:ser>/g)].map((match) => match[1] ?? '');
+    if (!seriesXml.length)
+        return null;
+    const points = (block, numeric) => { const result = []; for (const match of block.matchAll(/<c:pt\b[^>]*idx="(\d+)"[^>]*>[\s\S]*?<c:v>([\s\S]*?)<\/c:v>[\s\S]*?<\/c:pt>/g))
+        result[Number(match[1])] = numeric ? Number(match[2]) || 0 : entities(match[2] ?? ''); return result; };
+    const parsed = seriesXml.map((series, index) => { const cat = series.match(/<c:cat[\s\S]*?<\/c:cat>/)?.[0] ?? ''; const val = series.match(/<c:val[\s\S]*?<\/c:val>/)?.[0] ?? ''; const name = entities(series.match(/<c:tx[\s\S]*?<c:v>([\s\S]*?)<\/c:v>/)?.[1] ?? `Series ${index + 1}`); const color = `#${series.match(/<a:srgbClr\b[^>]*val="([0-9a-f]{6})"/i)?.[1] ?? ['004586', 'ff420e', 'ffd320', '579d1c'][index % 4]}`; return { name, color, categories: points(cat, false).map(String), values: points(val, true).map(Number) }; });
+    const categories = parsed[0]?.categories ?? [];
+    if (!categories.length)
+        return null;
+    const title = entities([...xml.matchAll(/<c:title[\s\S]*?<a:t>([\s\S]*?)<\/a:t>[\s\S]*?<\/c:title>/g)].map((match) => match[1]).join(' '));
+    return { title, categories, series: parsed.map(({ name, color, values }) => ({ name, color, values })) };
+}

package/dist/viewers/word/index.d.ts

@@ -0,0 +1,32 @@
+import { type HostContext, type NavigationService, type PrintService } from '../../host/index.js';
+import { type MountOptions, type ViewerHandle, type ViewerInput } from '../types.js';
+import { type WordController } from './controller.js';
+import { type SheetModule, type ZipModule } from './docx-preprocess.js';
+export * from './controller.js';
+export { wordViewerCss } from './styles.js';
+export declare const WORD_VIEWER_META: {
+    id: string;
+    displayNameKey: string;
+    extensions: string[];
+    priority: number;
+    requiredServices: readonly [];
+    optionalServices: readonly ["print", "navigation"];
+    inputOwnership: "consumes";
+};
+export declare const WORD_MAX_INPUT_BYTES: number;
+export interface DocxPreviewModule {
+    renderAsync(data: ArrayBuffer | Uint8Array, body: HTMLElement, styleContainer?: HTMLElement, options?: Record<string, unknown>): Promise<unknown>;
+}
+export interface WordViewerDeps {
+    loadDocxPreview(): Promise<DocxPreviewModule>;
+    loadZip(): Promise<ZipModule>;
+    loadSheet?(): Promise<SheetModule>;
+}
+export type WordViewerContext = HostContext & {
+    print?: PrintService;
+    navigation?: NavigationService;
+};
+export interface WordViewerHandle extends ViewerHandle {
+    readonly controller: WordController;
+}
+export declare function mountWordViewer(input: ViewerInput, container: HTMLElement, ctx: WordViewerContext, deps?: Partial<WordViewerDeps>, options?: MountOptions): Promise<WordViewerHandle>;

package/dist/viewers/word/index.js

@@ -0,0 +1,187 @@
+import { ALLOWED_LINK_SCHEMES } from '../../host/index.js';
+import { DocBinaryParser } from '../../parsers/doc-binary/index.js';
+import { MountAbortedError, VIEWER_ROOT_CLASS } from '../types.js';
+import { createWordController } from './controller.js';
+import { wordViewerCss } from './styles.js';
+import { DocxDecompressionLimitError, preprocessDocx } from './docx-preprocess.js';
+import { paginateLegacyDocument } from './paginate.js';
+import { normalizeDocxPreviewDom } from './normalize-docx.js';
+export * from './controller.js';
+export { wordViewerCss } from './styles.js';
+export const WORD_VIEWER_META = { id: 'word', displayNameKey: 'word.title', extensions: ['docx', 'doc'], priority: 15, requiredServices: [], optionalServices: ['print', 'navigation'], inputOwnership: 'consumes' };
+export const WORD_MAX_INPUT_BYTES = 50 * 1024 * 1024;
+const el = (tag, cls, text) => {
+    const node = document.createElement(tag);
+    if (cls)
+        node.className = cls;
+    if (text !== undefined)
+        node.textContent = text;
+    return node;
+};
+export async function mountWordViewer(input, container, ctx, deps = {}, options = {}) {
+    if (options.signal?.aborted)
+        throw new MountAbortedError();
+    if (input.data.byteLength > WORD_MAX_INPUT_BYTES)
+        throw new Error(ctx.i18n.t('diag.word.limit-exceeded'));
+    const root = options.styleIsolation !== 'scoped' && typeof container.attachShadow === 'function' ? (container.shadowRoot ?? container.attachShadow({ mode: 'open' })) : container;
+    root.replaceChildren();
+    if (root === container)
+        container.classList.add(VIEWER_ROOT_CLASS, 'omni-viewer--word');
+    else {
+        const style = el('style');
+        style.textContent = wordViewerCss;
+        root.append(style);
+    }
+    const frame = el('section', 'omni-word');
+    const header = el('header', 'omni-word__header');
+    header.append(el('span', 'omni-word__title', `📄 ${input.fileName}`), el('span', 'omni-word__meta', `${formatBytes(input.data.byteLength)} · ${input.fileName.toLowerCase().endsWith('.docx') ? 'DOCX' : 'legacy DOC'}`));
+    const toolbar = el('div', 'omni-word__toolbar');
+    const out = el('button', undefined, '−'), level = el('span', 'omni-word__zoom', '100%'), inc = el('button', undefined, '+'), reset = el('button', undefined, ctx.i18n.t('word.reset')), print = el('button', undefined, ctx.i18n.t('word.print'));
+    out.type = inc.type = reset.type = print.type = 'button';
+    out.setAttribute('aria-label', ctx.i18n.t('word.zoomOut'));
+    inc.setAttribute('aria-label', ctx.i18n.t('word.zoomIn'));
+    reset.setAttribute('aria-label', ctx.i18n.t('word.reset'));
+    print.setAttribute('aria-label', ctx.i18n.t('word.print'));
+    if (!ctx.print) {
+        print.disabled = true;
+        print.title = ctx.i18n.t('word.printUnavailable');
+    }
+    toolbar.append(out, level, inc, reset, print);
+    const viewport = el('main', 'omni-word__viewport');
+    const content = el('div', 'omni-word__content');
+    content.setAttribute('role', 'document');
+    viewport.append(content);
+    frame.append(header, toolbar, viewport);
+    root.append(frame);
+    const controller = createWordController();
+    const disposers = [];
+    const listen = (target, name, fn) => { target.addEventListener(name, fn); disposers.push(() => target.removeEventListener(name, fn)); };
+    const off = controller.subscribe((state) => { content.style.transform = `scale(${state.zoom})`; level.textContent = `${Math.round(state.zoom * 100)}%`; });
+    out.onclick = () => controller.dispatch({ type: 'zoom-out' });
+    inc.onclick = () => controller.dispatch({ type: 'zoom-in' });
+    reset.onclick = () => controller.dispatch({ type: 'reset-zoom' });
+    print.onclick = () => void ctx.print?.print();
+    listen(frame, 'keydown', ((event) => { if (!(event.ctrlKey || event.metaKey))
+        return; if (event.key === '+' || event.key === '=')
+        controller.dispatch({ type: 'zoom-in' });
+    else if (event.key === '-')
+        controller.dispatch({ type: 'zoom-out' });
+    else if (event.key === '0')
+        controller.dispatch({ type: 'reset-zoom' });
+    else if (event.key.toLowerCase() === 'p' && ctx.print)
+        void ctx.print.print();
+    else
+        return; event.preventDefault(); }));
+    listen(viewport, 'wheel', ((event) => { if (!(event.ctrlKey || event.metaKey))
+        return; event.preventDefault(); controller.dispatch({ type: event.deltaY < 0 ? 'zoom-in' : 'zoom-out' }); }));
+    try {
+        if (input.fileName.toLowerCase().endsWith('.docx')) {
+            content.classList.add('word-content', 'docx-mode');
+            content.classList.remove('legacy-mode');
+            if (!deps.loadDocxPreview)
+                throw new Error(ctx.i18n.t('diag.word.missing-dependency'));
+            if (!deps.loadZip)
+                throw new Error(ctx.i18n.t('diag.word.missing-dependency'));
+            const [docx, zip, sheet] = await Promise.all([deps.loadDocxPreview(), deps.loadZip(), deps.loadSheet?.()]);
+            if (options.signal?.aborted)
+                throw new MountAbortedError();
+            const prepared = await preprocessDocx(input.data, zip, sheet);
+            await docx.renderAsync(prepared.data, content, content, { inWrapper: true, breakPages: true, ignoreWidth: false, ignoreHeight: false, ignoreFonts: false, renderHeaders: true, renderFooters: true });
+            injectDocxPlaceholders(content, prepared.placeholders);
+            normalizeDocxPreviewDom(content);
+            secureDocxDom(content, ctx, disposers);
+        }
+        else {
+            content.classList.add('word-content', 'legacy-mode');
+            if (!deps.loadSheet)
+                ctx.logger.log('warn', 'word: legacy embedded workbook previews disabled because loadSheet is unavailable');
+            if (!deps.loadZip)
+                ctx.logger.log('warn', 'word: legacy embedded package/chart previews disabled because loadZip is unavailable');
+            const [legacyZip, legacySheet] = await Promise.all([deps.loadZip?.(), deps.loadSheet?.()]);
+            const legacyHtml = await DocBinaryParser.parseBytes(input.data, { jszip: legacyZip, xlsx: legacySheet });
+            const parsed = new DOMParser().parseFromString(legacyHtml, 'text/html');
+            parsed.querySelectorAll('script:not(.ov-doc-legacy-section-meta),iframe,object,embed').forEach((node) => node.remove());
+            const fragment = document.createDocumentFragment();
+            for (const child of [...parsed.body.childNodes])
+                fragment.append(document.importNode(child, true));
+            content.append(fragment);
+            secureDocxDom(content, ctx, disposers);
+            paginateLegacyDocument(content);
+        }
+    }
+    catch (error) {
+        if (error instanceof MountAbortedError) {
+            off();
+            disposers.forEach((dispose) => dispose());
+            frame.remove();
+            throw error;
+        }
+        content.replaceChildren(el('div', 'omni-word__error', error instanceof DocxDecompressionLimitError ? ctx.i18n.t('diag.word.decompression-limit') : error instanceof Error ? error.message : String(error)));
+    }
+    return { controller, dispose() { off(); disposers.forEach((dispose) => dispose()); frame.remove(); } };
+}
+function formatBytes(bytes) { if (bytes < 1024)
+    return `${bytes} B`; if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`; return `${(bytes / 1024 / 1024).toFixed(1)} MB`; }
+function injectDocxPlaceholders(root, placeholders) {
+    for (const placeholder of placeholders) {
+        const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+        let node;
+        while ((node = walker.nextNode())) {
+            const value = node.textContent ?? '';
+            const index = value.indexOf(placeholder.token);
+            if (index < 0 || !node.parentNode)
+                continue;
+            const fragment = document.createDocumentFragment();
+            if (index)
+                fragment.append(value.slice(0, index));
+            fragment.append(placeholder.kind === 'chart' ? renderChart(placeholder.chart) : renderEmbeddedSheet(placeholder.title, placeholder.rows));
+            if (index + placeholder.token.length < value.length)
+                fragment.append(value.slice(index + placeholder.token.length));
+            node.parentNode.replaceChild(fragment, node);
+            break;
+        }
+    }
+}
+function renderEmbeddedSheet(title, rows) {
+    const section = el('section', 'omni-word__embedded-sheet');
+    section.append(el('h3', undefined, title));
+    const table = el('table', 'omni-word__legacy-table');
+    rows.forEach((row, rowIndex) => { const tr = el('tr'); row.forEach((value) => tr.append(el(rowIndex ? 'td' : 'th', undefined, value))); table.append(tr); });
+    section.append(table);
+    return section;
+}
+function renderChart(chart) {
+    const card = el('figure', 'omni-word__chart');
+    card.setAttribute('aria-label', chart.title || 'Chart');
+    if (chart.title)
+        card.append(el('figcaption', undefined, chart.title));
+    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    svg.setAttribute('viewBox', '0 0 640 300');
+    svg.setAttribute('role', 'img');
+    const max = Math.max(1, ...chart.series.flatMap((series) => series.values));
+    const group = 520 / Math.max(1, chart.categories.length), bar = group / Math.max(1, chart.series.length + 1);
+    chart.series.forEach((series, seriesIndex) => series.values.forEach((value, valueIndex) => { const rect = document.createElementNS(svg.namespaceURI, 'rect'); const height = Math.max(0, value) / max * 220; rect.setAttribute('x', String(70 + valueIndex * group + seriesIndex * bar)); rect.setAttribute('y', String(250 - height)); rect.setAttribute('width', String(Math.max(2, bar - 2))); rect.setAttribute('height', String(height)); rect.setAttribute('fill', series.color); svg.append(rect); }));
+    card.append(svg);
+    const legend = el('div', 'omni-word__chart-legend');
+    chart.series.forEach((series) => { const item = el('span', undefined, series.name); item.style.borderLeft = `12px solid ${series.color}`; legend.append(item); });
+    card.append(legend);
+    return card;
+}
+function secureDocxDom(root, ctx, disposers) {
+    root.querySelectorAll('img,source,video,audio').forEach((node) => { for (const attr of ['src', 'srcset']) {
+        const value = node.getAttribute(attr);
+        if (value && /^(?:https?:)?\/\//i.test(value))
+            node.removeAttribute(attr);
+    } });
+    root.querySelectorAll('a').forEach((anchor) => { const href = anchor.getAttribute('href') ?? ''; anchor.removeAttribute('href'); anchor.removeAttribute('target'); let allowed = false; try {
+        allowed = ALLOWED_LINK_SCHEMES.includes(new URL(href).protocol);
+    }
+    catch {
+        allowed = false;
+    } if (!allowed || !ctx.navigation) {
+        anchor.setAttribute('aria-disabled', 'true');
+        return;
+    } anchor.setAttribute('role', 'link'); anchor.tabIndex = 0; const open = (event) => { event.preventDefault(); void ctx.navigation?.openExternalUrl(href); }; anchor.addEventListener('click', open); disposers.push(() => anchor.removeEventListener('click', open)); });
+    root.querySelectorAll('iframe,object,embed,script:not(.ov-doc-legacy-section-meta)').forEach((node) => node.remove());
+}

package/dist/viewers/word/normalize-docx.d.ts

@@ -0,0 +1,2 @@
+/** Normalizes glyphs emitted by docx-preview for Wingdings/PUA list markers. */
+export declare function normalizeDocxPreviewDom(wordContent: HTMLElement): void;

package/dist/viewers/word/normalize-docx.js

@@ -0,0 +1,50 @@
+/** Normalizes glyphs emitted by docx-preview for Wingdings/PUA list markers. */
+export function normalizeDocxPreviewDom(wordContent) {
+    const brokenBulletPrefix = /^[\u25A1\u25A0\u25FB\u25FC\uF0A7\uF0B7]\s*/;
+    const brokenBulletSingle = /[\u25A1\u25A0\u25FB\u25FC\uF0A7\uF0B7]/;
+    const normalizeLeadingGlyph = (element) => {
+        for (const node of element.childNodes) {
+            if (node.nodeType !== Node.TEXT_NODE)
+                continue;
+            const value = node.textContent ?? '', trimmed = value.trimStart();
+            if (!trimmed)
+                continue;
+            if (brokenBulletPrefix.test(trimmed)) {
+                const leadingSpaces = value.slice(0, value.length - trimmed.length);
+                node.textContent = `${leadingSpaces}${trimmed.replace(brokenBulletPrefix, '* ')}`;
+            }
+            break;
+        }
+    };
+    wordContent.querySelectorAll('p, li').forEach((element) => {
+        normalizeLeadingGlyph(element);
+        const firstSpan = element.querySelector('span');
+        if (firstSpan && brokenBulletPrefix.test(firstSpan.textContent ?? ''))
+            firstSpan.textContent = (firstSpan.textContent ?? '').replace(brokenBulletPrefix, '* ');
+    });
+    wordContent.querySelectorAll('p[class*="docx-num-"], li[class*="docx-num-"]').forEach((element) => {
+        const beforeContent = window.getComputedStyle(element, '::before').content ?? '';
+        if (brokenBulletSingle.test(beforeContent))
+            element.setAttribute('data-ov-bullet-fix', '1');
+    });
+    normalizeChartSpacerParagraphs(wordContent);
+}
+function normalizeChartSpacerParagraphs(root) {
+    const visualEmpty = (paragraph) => paragraph.tagName === 'P' && !paragraph.querySelector('.omni-word__chart,.ov-chart-card,table,img,svg,canvas,object,iframe') && (paragraph.textContent ?? '').replace(/\u200b/g, '').trim() === '';
+    root.querySelectorAll('p[data-ov-chart-spacer]').forEach((element) => element.removeAttribute('data-ov-chart-spacer'));
+    root.querySelectorAll('p').forEach((paragraph) => {
+        if (!paragraph.querySelector('.omni-word__chart,.ov-chart-card'))
+            return;
+        const clone = paragraph.cloneNode(true);
+        clone.querySelectorAll('.omni-word__chart,.ov-chart-card').forEach((node) => node.remove());
+        if ((clone.textContent ?? '').replace(/\u200b/g, '').trim())
+            return;
+        const empty = [];
+        let sibling = paragraph.nextElementSibling;
+        while (sibling && visualEmpty(sibling)) {
+            empty.push(sibling);
+            sibling = sibling.nextElementSibling;
+        }
+        empty.forEach((element, index) => element.setAttribute('data-ov-chart-spacer', index === 0 ? 'keep' : 'trim'));
+    });
+}

package/dist/viewers/word/paginate.d.ts

@@ -0,0 +1 @@
+export declare function paginateLegacyDocument(wordContent: HTMLElement): void;