@file-viewer/renderer-word 3.0.3 → 3.1.0

package/dist/docxAnchors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A paragraph-relative vertical anchor makes that paragraph an absolute-position
+ * containing block. Its horizontal axis can still be relative to the column or
+ * page margins: paragraph indentation must not be added to that authored offset.
+ * Keep the engine's original CSS length and correct only the containing-block
+ * origin. Recompute after fitting/resizing; never accumulate pixel corrections.
+ */
+export declare function correctDocxMixedAnchorOrigins(section: HTMLElement): void;

package/dist/docxAnchors.js

@@ -0,0 +1,60 @@
+const authoredLeft = new WeakMap();
+const number = (value) => Number.parseFloat(value) || 0;
+/**
+ * A paragraph-relative vertical anchor makes that paragraph an absolute-position
+ * containing block. Its horizontal axis can still be relative to the column or
+ * page margins: paragraph indentation must not be added to that authored offset.
+ * Keep the engine's original CSS length and correct only the containing-block
+ * origin. Recompute after fitting/resizing; never accumulate pixel corrections.
+ */
+export function correctDocxMixedAnchorOrigins(section) {
+    var _a;
+    const view = section.ownerDocument.defaultView;
+    if (!view)
+        return;
+    const pageRect = section.getBoundingClientRect();
+    const pageStyle = view.getComputedStyle(section);
+    const pageWidth = number(pageStyle.width) + (pageStyle.boxSizing === 'border-box' ? 0 :
+        number(pageStyle.paddingLeft) + number(pageStyle.paddingRight) + number(pageStyle.borderLeftWidth) + number(pageStyle.borderRightWidth));
+    const scale = pageWidth ? pageRect.width / pageWidth : 0;
+    if (!Number.isFinite(scale) || scale <= 0)
+        return;
+    for (const anchor of section.querySelectorAll('[data-docx-anchor-horizontal="column"], [data-docx-anchor-horizontal="margin"]')) {
+        const paragraph = anchor.closest('[data-docx-anchor-context="paragraph"]');
+        if (!paragraph || anchor.offsetParent !== paragraph || view.getComputedStyle(anchor).position !== 'absolute' || !anchor.style.left)
+            continue;
+        // Cell-relative drawings are left to the engine's layoutInCell policy.
+        if (paragraph.closest('td, th'))
+            continue;
+        const root = anchor.dataset.docxAnchorHorizontal === 'margin'
+            ? section : paragraph.closest('article, header, footer');
+        if (!root || !section.contains(root) && root !== section)
+            continue;
+        const rootStyle = view.getComputedStyle(root);
+        const rootRect = root.getBoundingClientRect();
+        let origin = rootRect.left + (number(rootStyle.borderLeftWidth) + number(rootStyle.paddingLeft)) * scale;
+        const paragraphStyle = view.getComputedStyle(paragraph);
+        const paragraphRect = paragraph.getBoundingClientRect();
+        if (root !== section) {
+            const count = number(rootStyle.columnCount);
+            const width = number(rootStyle.columnWidth);
+            if (count > 1 || width > 0) {
+                const gap = rootStyle.columnGap === 'normal' ? number(rootStyle.fontSize) : number(rootStyle.columnGap);
+                const contentWidth = root.clientWidth - number(rootStyle.paddingLeft) - number(rootStyle.paddingRight);
+                const columns = count > 0 ? count : Math.max(1, Math.floor((contentWidth + gap) / (width + gap)));
+                const stride = (contentWidth + gap) / columns;
+                if (stride > 0) {
+                    const unindentedLeft = (paragraphRect.left - origin) / scale - number(paragraphStyle.marginLeft);
+                    origin += Math.round(unindentedLeft / stride) * stride * scale;
+                }
+            }
+        }
+        const containingOrigin = paragraphRect.left + number(paragraphStyle.borderLeftWidth) * scale;
+        const correction = (origin - containingOrigin) / scale;
+        if (!Number.isFinite(correction))
+            continue;
+        const left = (_a = authoredLeft.get(anchor)) !== null && _a !== void 0 ? _a : anchor.style.left;
+        authoredLeft.set(anchor, left);
+        anchor.style.left = Math.abs(correction) < 0.01 ? left : `calc(${left} + ${correction.toFixed(4)}px)`;
+    }
+}

package/dist/index.d.ts

@@ -8,9 +8,10 @@ export declare const renderFileViewerWordDocx: FileRenderHandler<FileViewerRende
 /**
  * A surprising number of legacy systems keep the `.doc` suffix after saving
  * an OOXML document. Route those ZIP-based files through the DOCX engine while
- * leaving genuine OLE/CFB `.doc` files on the binary parser.
+ * leaving genuine OLE/CFB `.doc` files on the binary parser. Word 2003 XML
+ * has its own single-file container and is adapted lazily to the OOXML renderer.
  */
-export declare const resolveFileViewerWordContainer: (buffer: ArrayBuffer) => "openxml" | "binary";
+export declare const resolveFileViewerWordContainer: (buffer: ArrayBuffer) => "openxml" | "wordml" | "binary";
 export declare const renderFileViewerWordDoc: FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>;
 export declare const renderFileViewerOpenDocument: FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>;
 export declare const wordRenderer: FileViewerRendererPlugin<FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>>;

package/dist/index.js

@@ -15,18 +15,33 @@ export const renderFileViewerWordDocx = (buffer, target, _type, context) => impo
 /**
  * A surprising number of legacy systems keep the `.doc` suffix after saving
  * an OOXML document. Route those ZIP-based files through the DOCX engine while
- * leaving genuine OLE/CFB `.doc` files on the binary parser.
+ * leaving genuine OLE/CFB `.doc` files on the binary parser. Word 2003 XML
+ * has its own single-file container and is adapted lazily to the OOXML renderer.
  */
 export const resolveFileViewerWordContainer = (buffer) => {
     if (buffer.byteLength < 2) {
         return 'binary';
     }
     const bytes = new Uint8Array(buffer, 0, 2);
-    return bytes[0] === 0x50 && bytes[1] === 0x4b ? 'openxml' : 'binary';
+    if (bytes[0] === 0x50 && bytes[1] === 0x4b)
+        return 'openxml';
+    const prefix = new Uint8Array(buffer, 0, Math.min(buffer.byteLength, 8192));
+    const utf16le = (bytes[0] === 0xff && bytes[1] === 0xfe) || (bytes[0] === 0x3c && bytes[1] === 0);
+    const utf16be = (bytes[0] === 0xfe && bytes[1] === 0xff) || (bytes[0] === 0 && bytes[1] === 0x3c);
+    const text = new TextDecoder(utf16le ? 'utf-16le' : utf16be ? 'utf-16be' : 'utf-8').decode(prefix);
+    return /<(?:[\w.-]+:)?wordDocument(?:\s|>)/.test(text) &&
+        text.includes('http://schemas.microsoft.com/office/word/2003/wordml') ? 'wordml' : 'binary';
+};
+export const renderFileViewerWordDoc = (buffer, target, _type, context) => {
+    const container = resolveFileViewerWordContainer(buffer);
+    if (container === 'wordml') {
+        return Promise.all([import('./wordMl.js'), import('./wordDocx.js')])
+            .then(async ([{ convertWordMlToDocx }, { default: renderWordDocx }]) => renderWordDocx(await convertWordMlToDocx(buffer, target), target, context));
+    }
+    return container === 'openxml'
+        ? import('./wordDocx.js').then(({ default: renderWordDocx }) => renderWordDocx(buffer, target, context))
+        : import('./wordDoc.js').then(({ default: renderWordDoc }) => renderWordDoc(buffer, target, context));
 };
-export const renderFileViewerWordDoc = (buffer, target, _type, context) => resolveFileViewerWordContainer(buffer) === 'openxml'
-    ? import('./wordDocx.js').then(({ default: renderWordDocx }) => renderWordDocx(buffer, target, context))
-    : import('./wordDoc.js').then(({ default: renderWordDoc }) => renderWordDoc(buffer, target, context));
 export const renderFileViewerOpenDocument = (buffer, target, type, context) => import('./openDocument.js').then(({ default: renderOpenDocument }) => renderOpenDocument(buffer, target, type, context));
 export const wordRenderer = {
     id: 'file-viewer-renderer-word',

package/dist/wordDocx.js

@@ -1,4 +1,5 @@
 import JSZip from 'jszip';
+import { correctDocxMixedAnchorOrigins } from './docxAnchors.js';
 import { DEFAULT_FILE_VIEWER_DOCX_RUNTIME_VERSION, resolveFileViewerDocxWorkerJsZipUrl, resolveFileViewerDocxWorkerUrl, resolveFileViewerRuntimeAssetBaseUrl, } from '@file-viewer/core/assets';
 import { applyPrintPageSize, buildPrintPageStyle, createFileViewerTranslator, createFileViewerZoomChangeEmitter as createZoomChangeEmitter, formatCssPixels, getElementPrintPageSize, normalizeFileViewerTheme, replaceFileViewerCanvasWithImages, registerFileViewerZoomProvider, resolveFileViewerFitScale, unregisterFileViewerZoomProvider, waitForFileViewerNextPaint, } from '@file-viewer/core';
 const DOCX_DEFAULT_PAGE_SIZE = {
@@ -482,6 +483,7 @@ function makeDocxResponsive(target, context) {
                 return;
             }
             page.style.transform = 'translateX(-50%)';
+            correctDocxMixedAnchorOrigins(page);
             const pageWidth = page.offsetWidth;
             const contentHeight = pagedLayout
                 ? page.offsetHeight

package/dist/wordMl.d.ts

@@ -0,0 +1,8 @@
+export declare function decodeWordMlBytes(buffer: ArrayBuffer): string;
+/**
+ * Adapt the single-file Word 2003 XML container to the existing OOXML renderer.
+ * This is structural conversion, not HTML insertion or remote conversion. Body,
+ * styles, table properties, section geometry and VML remain renderer-owned.
+ * Inline headers/footers become package parts; only embedded image data is read.
+ */
+export declare function convertWordMlToDocx(buffer: ArrayBuffer, target: HTMLElement): Promise<ArrayBuffer>;

package/dist/wordMl.js

@@ -0,0 +1,211 @@
+import JSZip from 'jszip';
+const WORDML = 'http://schemas.microsoft.com/office/word/2003/wordml';
+const WORD = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const PACKAGE_REL = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const CONTENT_TYPES = 'http://schemas.openxmlformats.org/package/2006/content-types';
+const AUX = 'http://schemas.microsoft.com/office/word/2003/auxHint';
+const VML = 'urn:schemas-microsoft-com:vml';
+const XMLNS = 'http://www.w3.org/2000/xmlns/';
+const aliases = {
+    'h-ansi': 'hAnsi', fareast: 'eastAsia', 'b-cs': 'bCs', 'i-cs': 'iCs',
+    'sz-cs': 'szCs', 'lang-cs': 'lang', 'panose-1': 'panose1',
+    'line-rule': 'lineRule', 'line-pitch': 'linePitch', 'char-space': 'charSpace',
+    'hanging-chars': 'hangingChars', 'first-line': 'firstLine',
+    'first-line-chars': 'firstLineChars', 'left-chars': 'leftChars', 'right-chars': 'rightChars',
+};
+export function decodeWordMlBytes(buffer) {
+    const bytes = new Uint8Array(buffer);
+    const utf16le = (bytes[0] === 0xff && bytes[1] === 0xfe) || (bytes[0] === 0x3c && bytes[1] === 0);
+    const utf16be = (bytes[0] === 0xfe && bytes[1] === 0xff) || (bytes[0] === 0 && bytes[1] === 0x3c);
+    return new TextDecoder(utf16le ? 'utf-16le' : utf16be ? 'utf-16be' : 'utf-8').decode(bytes);
+}
+/**
+ * Adapt the single-file Word 2003 XML container to the existing OOXML renderer.
+ * This is structural conversion, not HTML insertion or remote conversion. Body,
+ * styles, table properties, section geometry and VML remain renderer-owned.
+ * Inline headers/footers become package parts; only embedded image data is read.
+ */
+export async function convertWordMlToDocx(buffer, target) {
+    var _a, _b, _c, _d;
+    const source = decodeWordMlBytes(buffer);
+    if (/<!DOCTYPE\b|<!ENTITY\b/i.test(source)) {
+        throw new Error('Word 2003 XML must not contain a DTD or entity declarations.');
+    }
+    const view = target.ownerDocument.defaultView;
+    const Parser = (_a = view === null || view === void 0 ? void 0 : view.DOMParser) !== null && _a !== void 0 ? _a : globalThis.DOMParser;
+    const Serializer = (_b = view === null || view === void 0 ? void 0 : view.XMLSerializer) !== null && _b !== void 0 ? _b : globalThis.XMLSerializer;
+    const input = new Parser().parseFromString(source, 'application/xml');
+    if (input.getElementsByTagName('parsererror').length || input.documentElement.localName !== 'wordDocument' || input.documentElement.namespaceURI !== WORDML) {
+        throw new Error('Invalid Word 2003 XML document.');
+    }
+    const body = Array.from(input.documentElement.children).find(element => element.namespaceURI === WORDML && element.localName === 'body');
+    if (!body)
+        throw new Error('Word 2003 XML document has no body.');
+    const zip = new JSZip();
+    const serializer = new Serializer();
+    const overrides = [];
+    const images = new Map();
+    // Never resolve a WordML image name as a file/HTTP URL. It must have binData.
+    for (const binary of Array.from(input.getElementsByTagNameNS(WORDML, 'binData'))) {
+        const name = binary.getAttributeNS(WORDML, 'name') || '';
+        if (images.has(name))
+            continue;
+        const extension = (_c = /\.(png|jpe?g|gif|bmp|tiff?|emf|wmf)$/i.exec(name)) === null || _c === void 0 ? void 0 : _c[1].toLowerCase();
+        const bytes = ((_d = binary.textContent) === null || _d === void 0 ? void 0 : _d.replace(/\s/g, '')) || '';
+        if (name && extension && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(bytes) && bytes) {
+            const path = `media/image${images.size + 1}.${extension}`;
+            images.set(name, { path, bytes });
+            zip.file(`word/${path}`, bytes, { base64: true });
+        }
+    }
+    const createDocument = (name) => {
+        const doc = input.implementation.createDocument(WORD, `w:${name}`, null);
+        doc.documentElement.setAttributeNS(XMLNS, 'xmlns:r', REL);
+        return doc;
+    };
+    const serialize = (document) => `<?xml version="1.0" encoding="UTF-8"?>${serializer.serializeToString(document)}`;
+    const relationships = new Map();
+    function relate(part, type, destination) {
+        let doc = relationships.get(part);
+        if (!doc) {
+            doc = input.implementation.createDocument(PACKAGE_REL, 'Relationships', null);
+            relationships.set(part, doc);
+        }
+        const id = `rId${doc.documentElement.children.length + 1}`;
+        const item = doc.createElementNS(PACKAGE_REL, 'Relationship');
+        item.setAttribute('Id', id);
+        item.setAttribute('Type', `${REL}/${type}`);
+        item.setAttribute('Target', destination);
+        doc.documentElement.appendChild(item);
+        return id;
+    }
+    let headerNumber = 0;
+    let footerNumber = 0;
+    function appendConverted(node, parent, part, depth = 0) {
+        if (depth > 256)
+            throw new Error('Word 2003 XML nesting is too deep.');
+        const output = parent.ownerDocument;
+        if (node.nodeType === 3 || node.nodeType === 4) {
+            parent.appendChild(output.createTextNode(node.textContent || ''));
+            return;
+        }
+        if (node.nodeType !== 1)
+            return;
+        const element = node;
+        const isWord = element.namespaceURI === WORDML;
+        if (isWord && element.localName === 'binData')
+            return;
+        if (element.namespaceURI === AUX) {
+            // wx:sect and wx:sub-section are grouping hints, not content containers.
+            for (const child of Array.from(element.childNodes))
+                appendConverted(child, parent, part, depth + 1);
+            return;
+        }
+        if (isWord && (element.localName === 'hdr' || element.localName === 'ftr') && parent.localName === 'sectPr') {
+            const header = element.localName === 'hdr';
+            const partName = `${header ? 'header' : 'footer'}${header ? ++headerNumber : ++footerNumber}.xml`;
+            const document = createDocument(header ? 'hdr' : 'ftr');
+            for (const child of Array.from(element.childNodes))
+                appendConverted(child, document.documentElement, partName, depth + 1);
+            zip.file(`word/${partName}`, serialize(document));
+            overrides.push([`/word/${partName}`, `application/vnd.openxmlformats-officedocument.wordprocessingml.${header ? 'header' : 'footer'}+xml`]);
+            const reference = output.createElementNS(WORD, `w:${header ? 'header' : 'footer'}Reference`);
+            const type = element.getAttributeNS(WORDML, 'type');
+            reference.setAttributeNS(WORD, 'w:type', type === 'first' || type === 'even' ? type : 'default');
+            reference.setAttributeNS(REL, 'r:id', relate(part, header ? 'header' : 'footer', partName));
+            parent.appendChild(reference);
+            return;
+        }
+        const namespace = isWord ? WORD : element.namespaceURI;
+        const localName = isWord ? aliases[element.localName] || element.localName : element.localName;
+        const name = isWord ? `w:${localName}` : element.nodeName;
+        const converted = output.createElementNS(namespace, name);
+        for (const attribute of Array.from(element.attributes)) {
+            if (attribute.namespaceURI === XMLNS)
+                continue;
+            // VML image references are replaced with package-local relationships below.
+            if (namespace === VML && (localName === 'imagedata' || localName === 'fill') && (attribute.localName === 'src' || attribute.localName === 'href'))
+                continue;
+            const wordAttribute = attribute.namespaceURI === WORDML;
+            const key = wordAttribute ? aliases[attribute.localName] || attribute.localName : attribute.localName;
+            let value = attribute.value;
+            if (wordAttribute && key === 'hint' && value === 'fareast')
+                value = 'eastAsia';
+            if (isWord && localName === 'fldChar' && wordAttribute && key === 'fldCharType' && value === 'start')
+                value = 'begin';
+            converted.setAttributeNS(wordAttribute ? WORD : attribute.namespaceURI, wordAttribute ? `w:${key}` : attribute.name, value);
+        }
+        if (namespace === VML && (localName === 'imagedata' || localName === 'fill')) {
+            const image = images.get(element.getAttribute('src') || '');
+            if (image)
+                converted.setAttributeNS(REL, 'r:id', relate(part, 'image', image.path));
+        }
+        parent.appendChild(converted);
+        for (const child of Array.from(element.childNodes))
+            appendConverted(child, converted, part, depth + 1);
+    }
+    const document = createDocument('document');
+    const outputBody = document.createElementNS(WORD, 'w:body');
+    document.documentElement.appendChild(outputBody);
+    for (const child of Array.from(body.childNodes))
+        appendConverted(child, outputBody, 'document.xml');
+    // In OOXML only the final section properties may be a direct body child.
+    // Earlier WordML wx:sect properties belong on the preceding paragraph.
+    for (const section of Array.from(outputBody.children)) {
+        if (section.localName !== 'sectPr' || section === outputBody.lastElementChild)
+            continue;
+        let paragraph = section.previousElementSibling;
+        if (!paragraph || paragraph.localName !== 'p') {
+            paragraph = document.createElementNS(WORD, 'w:p');
+            outputBody.insertBefore(paragraph, section);
+        }
+        let properties = Array.from(paragraph.children).find(child => child.localName === 'pPr');
+        if (!properties) {
+            properties = document.createElementNS(WORD, 'w:pPr');
+            paragraph.insertBefore(properties, paragraph.firstChild);
+        }
+        properties.appendChild(section);
+    }
+    zip.file('word/document.xml', serialize(document));
+    overrides.push(['/word/document.xml', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml']);
+    for (const [sourceName, rootName, path, type] of [
+        ['styles', 'styles', 'styles.xml', 'styles'],
+        ['fonts', 'fonts', 'fontTable.xml', 'fontTable'],
+        ['docPr', 'settings', 'settings.xml', 'settings'],
+    ]) {
+        const element = Array.from(input.documentElement.children).find(child => child.namespaceURI === WORDML && child.localName === sourceName);
+        if (!element)
+            continue;
+        const part = createDocument(rootName);
+        for (const child of Array.from(element.childNodes))
+            appendConverted(child, part.documentElement, path);
+        zip.file(`word/${path}`, serialize(part));
+        relate('document.xml', type, path);
+        overrides.push([`/word/${path}`, `application/vnd.openxmlformats-officedocument.wordprocessingml.${type}+xml`]);
+    }
+    for (const [part, relations] of relationships)
+        zip.file(`word/_rels/${part}.rels`, serialize(relations));
+    const rootRelations = input.implementation.createDocument(PACKAGE_REL, 'Relationships', null);
+    const office = rootRelations.createElementNS(PACKAGE_REL, 'Relationship');
+    for (const [name, value] of [['Id', 'rId1'], ['Type', `${REL}/officeDocument`], ['Target', 'word/document.xml']])
+        office.setAttribute(name, value);
+    rootRelations.documentElement.appendChild(office);
+    zip.file('_rels/.rels', serialize(rootRelations));
+    const types = input.implementation.createDocument(CONTENT_TYPES, 'Types', null);
+    const imageTypes = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', bmp: 'image/bmp', tif: 'image/tiff', tiff: 'image/tiff', emf: 'image/x-emf', wmf: 'image/x-wmf' };
+    for (const [extension, mime] of [['rels', 'application/vnd.openxmlformats-package.relationships+xml'], ['xml', 'application/xml'], ...Object.entries(imageTypes)]) {
+        const entry = types.createElementNS(CONTENT_TYPES, 'Default');
+        entry.setAttribute('Extension', extension);
+        entry.setAttribute('ContentType', mime);
+        types.documentElement.appendChild(entry);
+    }
+    for (const [path, mime] of overrides) {
+        const entry = types.createElementNS(CONTENT_TYPES, 'Override');
+        entry.setAttribute('PartName', path);
+        entry.setAttribute('ContentType', mime);
+        types.documentElement.appendChild(entry);
+    }
+    zip.file('[Content_Types].xml', serialize(types));
+    return zip.generateAsync({ type: 'arraybuffer' });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/renderer-word",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "private": false,
   "type": "module",
   "description": "Standalone DOCX, DOC, and OpenDocument renderer for File Viewer; RTF parsing is an explicit opt-in capability.",
@@ -58,9 +58,9 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@file-viewer/core": "3.0.3",
-    "@file-viewer/doc": "3.0.3",
-    "@file-viewer/docx": "0.3.31",
+    "@file-viewer/core": "3.1.0",
+    "@file-viewer/doc": "3.1.0",
+    "@file-viewer/docx": "0.3.32",
     "jszip": "3.10.2"
   },
   "devDependencies": {