@file-viewer/doc 2.2.5 → 2.2.7

package/dist/msdoc/constants.d.ts

@@ -2,6 +2,7 @@ export declare const DOC_CONTROL: {
     paragraph: string;
     cellMark: string;
     picture: string;
+    textBoxPlaceholder: string;
     fieldStart: string;
     fieldSeparator: string;
     fieldEnd: string;

package/dist/msdoc/constants.js

@@ -2,6 +2,7 @@ export const DOC_CONTROL = {
     paragraph: '\u000d',
     cellMark: '\u0007',
     picture: '\u0001',
+    textBoxPlaceholder: '\u0008',
     fieldStart: '\u0013',
     fieldSeparator: '\u0014',
     fieldEnd: '\u0015',

package/dist/msdoc/html-word.d.ts

@@ -0,0 +1,3 @@
+import type { MsDocParseResult } from '../types.js';
+export declare function isHtmlWordDocumentStream(bytes: Uint8Array): boolean;
+export declare function parseHtmlWordDocumentStream(bytes: Uint8Array): MsDocParseResult | null;

package/dist/msdoc/html-word.js

@@ -0,0 +1,178 @@
+import { charPropsToState, paraPropsToState } from './properties.js';
+const HTML_PREFIX_RE = /^(?:<!doctype\s+html\b|<html\b|<body\b)/i;
+const BLOCK_RE = /<(div|p|h[1-6]|li|pre|blockquote|tr)\b([^>]*)>([\s\S]*?)<\/\1\s*>/gi;
+const UNSAFE_CONTENT_RE = /<(script|style|noscript|iframe|object|embed|svg)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+function asciiPreview(bytes, length = 1024) {
+    return Array.from(bytes.subarray(0, Math.min(length, bytes.length)), byte => byte === 0 ? '' : String.fromCharCode(byte)).join('');
+}
+export function isHtmlWordDocumentStream(bytes) {
+    const preview = asciiPreview(bytes)
+        .replace(/^\uFEFF/, '')
+        .trimStart();
+    return HTML_PREFIX_RE.test(preview);
+}
+function decodeWith(bytes, label, fatal = false) {
+    try {
+        return new TextDecoder(label, { fatal }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+function decodeHtmlWordDocument(bytes) {
+    let end = bytes.length;
+    while (end > 0 && bytes[end - 1] === 0)
+        end -= 1;
+    const content = bytes.subarray(0, end);
+    const preview = asciiPreview(content, 4096);
+    const declared = /charset\s*=\s*["']?([a-z0-9._-]+)/i.exec(preview)?.[1]?.toLowerCase();
+    const declaredEncoding = declared === 'gb2312' || declared === 'gbk' ? 'gb18030' : declared;
+    if (declaredEncoding) {
+        const decoded = decodeWith(content, declaredEncoding);
+        if (decoded != null)
+            return decoded;
+    }
+    const utf8 = decodeWith(content, 'utf-8', true);
+    if (utf8 != null)
+        return utf8;
+    return decodeWith(content, 'gb18030') ?? decodeWith(content, 'utf-8') ?? '';
+}
+function decodeEntities(value) {
+    const named = {
+        amp: '&',
+        apos: "'",
+        gt: '>',
+        lt: '<',
+        nbsp: '\u00a0',
+        quot: '"',
+    };
+    return value.replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z][a-z0-9]+);/gi, (match, entity) => {
+        if (entity[0] === '#') {
+            const hexadecimal = entity[1]?.toLowerCase() === 'x';
+            const parsed = Number.parseInt(entity.slice(hexadecimal ? 2 : 1), hexadecimal ? 16 : 10);
+            if (Number.isFinite(parsed) && parsed >= 0 && parsed <= 0x10ffff) {
+                try {
+                    return String.fromCodePoint(parsed);
+                }
+                catch {
+                    return match;
+                }
+            }
+            return match;
+        }
+        return named[entity.toLowerCase()] ?? match;
+    });
+}
+function fragmentToText(fragment) {
+    return decodeEntities(fragment
+        .replace(UNSAFE_CONTENT_RE, '')
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<\/(?:div|p|h[1-6]|li|pre|blockquote|tr|table)>/gi, '\n')
+        .replace(/<\/?(?:td|th)\b[^>]*>/gi, '\t')
+        .replace(/<[^>]+>/g, '')
+        .replace(/\u0000/g, ''))
+        .replace(/\r\n?/g, '\n')
+        .replace(/[\t\f\v ]+/g, ' ')
+        .replace(/ *\n */g, '\n')
+        .trim();
+}
+function extractParagraphs(html) {
+    const safe = html.replace(UNSAFE_CONTENT_RE, '').replace(/<!--[\s\S]*?-->/g, '');
+    const paragraphs = [];
+    for (const match of safe.matchAll(BLOCK_RE)) {
+        const content = match[3] || '';
+        const text = fragmentToText(content);
+        if (!text)
+            continue;
+        paragraphs.push({ text, attributes: match[2] || '', content });
+    }
+    if (paragraphs.length)
+        return paragraphs;
+    const text = fragmentToText(safe);
+    return text ? [{ text, attributes: '', content: safe }] : [];
+}
+function readStyle(attributes) {
+    return /\bstyle\s*=\s*(["'])([\s\S]*?)\1/i.exec(attributes)?.[2] || '';
+}
+function createParagraph(source, index) {
+    const paraState = paraPropsToState([]);
+    const charState = charPropsToState([]);
+    const style = readStyle(source.attributes);
+    const alignment = /text-align\s*:\s*(center|right|justify)/i.exec(style)?.[1]?.toLowerCase();
+    if (alignment === 'center')
+        paraState.alignment = 1;
+    if (alignment === 'right')
+        paraState.alignment = 2;
+    if (alignment === 'justify')
+        paraState.alignment = 3;
+    const indentPoints = Number.parseFloat(/text-indent\s*:\s*([\d.]+)pt/i.exec(style)?.[1] || '');
+    if (Number.isFinite(indentPoints))
+        paraState.firstLineIndent = Math.round(indentPoints * 20);
+    const fontSizePoints = Number.parseFloat(/font-size\s*:\s*([\d.]+)pt/i.exec(style)?.[1] || '');
+    if (Number.isFinite(fontSizePoints)) {
+        charState.fontSizeHalfPoints = Math.round(Math.min(96, Math.max(8, fontSizePoints)) * 2);
+    }
+    if (/font-weight\s*:\s*(?:bold|[6-9]00)/i.test(style) ||
+        /<(?:b|strong)\b/i.test(source.content)) {
+        charState.bold = true;
+    }
+    if (/font-style\s*:\s*italic/i.test(style) || /<(?:i|em)\b/i.test(source.content)) {
+        charState.italic = true;
+    }
+    const inlines = source.text
+        .split('\n')
+        .flatMap((line, lineIndex) => [
+        ...(lineIndex ? [{ type: 'lineBreak' }] : []),
+        ...(line ? [{ type: 'text', text: line, style: { ...charState } }] : []),
+    ]);
+    return {
+        type: 'paragraph',
+        id: `html-word-paragraph-${index + 1}`,
+        styleId: 0,
+        styleName: 'Normal',
+        paraState,
+        inlines,
+        text: source.text,
+    };
+}
+export function parseHtmlWordDocumentStream(bytes) {
+    if (!isHtmlWordDocumentStream(bytes))
+        return null;
+    const paragraphs = extractParagraphs(decodeHtmlWordDocument(bytes));
+    if (!paragraphs.length)
+        return null;
+    const blocks = paragraphs.map(createParagraph);
+    const textLength = paragraphs.reduce((total, paragraph) => total + paragraph.text.length, 0);
+    return {
+        kind: 'msdoc',
+        version: 1,
+        warnings: [
+            {
+                message: 'Recovered an HTML document stored inside the legacy WordDocument stream.',
+                code: 'MSDOC_HTML_WORDDOCUMENT_RECOVERED',
+            },
+        ],
+        meta: {
+            fib: {
+                wIdent: 0,
+                nFib: 0,
+                fWhichTblStm: 0,
+                fComplex: false,
+                fEncrypted: false,
+                ccpText: textLength,
+            },
+            counts: {
+                paragraphs: blocks.length,
+                blocks: blocks.length,
+                assets: 0,
+                styles: 0,
+                fonts: 0,
+            },
+        },
+        fonts: [],
+        styles: [],
+        blocks,
+        assets: [],
+    };
+}

package/dist/msdoc/parser.js

@@ -5,6 +5,7 @@ import { DOC_CONTROL } from './constants.js';
 import { parseFib } from './fib.js';
 import { readChpxRuns, readPapxRuns } from './fkp.js';
 import { parseFonts } from './fonts.js';
+import { parseHtmlWordDocumentStream } from './html-word.js';
 import { extractObjectPool, extractPictureAsset } from './objects.js';
 import { applyTableStateToCells, charPropsToState, getTableDepth, paraPropsToState, tablePropsToState, } from './properties.js';
 import { mergePropertyArrays, parseStyles, splitPropertiesByKind } from './styles.js';
@@ -123,13 +124,68 @@ function normalizePlainTextChar(ch) {
         case DOC_CONTROL.nonBreakingHyphen:
             return '-';
         case DOC_CONTROL.nonRequiredHyphen:
-            return '';
         case DOC_CONTROL.annotationRef:
+        case DOC_CONTROL.textBoxPlaceholder:
             return '';
         default:
             return ch;
     }
 }
+function normalizeParagraphText(text) {
+    return text.replaceAll(DOC_CONTROL.textBoxPlaceholder, '');
+}
+function getDocumentStoryRanges(fib, documentLength) {
+    const storyLengths = [
+        ['main', fib.fibRgLw.ccpText],
+        ['footnote', fib.fibRgLw.ccpFtn],
+        ['header', fib.fibRgLw.ccpHdd],
+        ['macro', fib.fibRgLw.ccpMcr],
+        ['annotation', fib.fibRgLw.ccpAtn],
+        ['endnote', fib.fibRgLw.ccpEdn],
+        ['textbox', fib.fibRgLw.ccpTxbx],
+        ['header-textbox', fib.fibRgLw.ccpHdrTxbx],
+    ];
+    const hasDeclaredStories = storyLengths.some(([, length]) => length > 0);
+    if (!hasDeclaredStories)
+        return [{ kind: 'main', cpStart: 0, cpEnd: documentLength }];
+    const ranges = [];
+    let cp = 0;
+    for (const [kind, rawLength] of storyLengths) {
+        const length = Math.max(0, rawLength || 0);
+        const cpStart = Math.min(cp, documentLength);
+        cp += length;
+        const cpEnd = Math.min(cp, documentLength);
+        ranges.push({ kind, cpStart, cpEnd });
+    }
+    return ranges;
+}
+function buildStoryParagraphRanges(story, documentText, papxRuns) {
+    if (story.cpEnd <= story.cpStart)
+        return [];
+    const runs = papxRuns.filter((run) => run.cpStart < story.cpEnd && run.cpEnd > story.cpStart);
+    if (runs.length) {
+        return runs.map((run) => {
+            const cpStart = Math.max(story.cpStart, run.cpStart);
+            const cpEnd = Math.min(story.cpEnd, run.cpEnd);
+            return {
+                cpStart,
+                cpEnd,
+                terminator: documentText[cpEnd - 1] || '',
+                styleId: run.styleId,
+                properties: run.properties,
+                storyKind: story.kind,
+            };
+        }).filter((range) => range.cpEnd > range.cpStart);
+    }
+    return splitParagraphRanges(documentText.slice(story.cpStart, story.cpEnd)).map((range) => ({
+        ...range,
+        cpStart: range.cpStart + story.cpStart,
+        cpEnd: range.cpEnd + story.cpStart,
+        styleId: 0,
+        properties: [],
+        storyKind: story.kind,
+    }));
+}
 function buildInlineNodes(segments, resolveAsset) {
     const output = [];
     const fieldStack = [];
@@ -207,7 +263,7 @@ function buildInlineNodes(segments, resolveAsset) {
     }
     return output;
 }
-function buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps, resolveFont, cursorRef) {
+function buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps, resolveFont, cursorRef, forceReadableColors = false) {
     const overlaps = getOverlappingRuns(chpxRuns, range.cpStart, range.cpEnd, cursorRef);
     const boundaries = new Set([range.cpStart, range.cpEnd]);
     for (const run of overlaps) {
@@ -227,6 +283,8 @@ function buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps
         const charStyleProps = directState.charStyleId != null ? styles.resolveStyle(directState.charStyleId).charProps : [];
         const finalProps = mergePropertyArrays(baseCharProps, charStyleProps, directProps);
         const state = charPropsToState(finalProps);
+        if (forceReadableColors && state.colorIndex === 8)
+            state.colorIndex = 1;
         const font = resolveFont(state.fontFamilyId);
         if (font)
             state.fontFamily = font.name || font.altName || undefined;
@@ -245,6 +303,8 @@ function buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps
     }
     if (!segments.length && paragraphText) {
         const state = charPropsToState(baseCharProps);
+        if (forceReadableColors && state.colorIndex === 8)
+            state.colorIndex = 1;
         const font = resolveFont(state.fontFamilyId);
         if (font)
             state.fontFamily = font.name || font.altName || undefined;
@@ -264,7 +324,7 @@ function buildParagraphModel(range, paragraphText, styles, fonts, chpxRuns, reso
     const tableState = tablePropsToState(tableProps);
     const baseCharProps = paraStyle.charProps;
     const resolveFont = (fontId) => fonts.byIndex(fontId);
-    const segments = buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps, resolveFont, chpxCursor);
+    const segments = buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps, resolveFont, chpxCursor, range.storyKind === 'textbox' || range.storyKind === 'header-textbox');
     const inlines = buildInlineNodes(segments, resolveAsset);
     return {
         id: uniqueId('para'),
@@ -587,6 +647,11 @@ export function parseMsDoc(input, options = {}) {
     const wordBytes = cfb.getStream('/WordDocument');
     if (!wordBytes)
         throw new Error('Missing WordDocument stream');
+    const htmlDocument = parseHtmlWordDocumentStream(wordBytes);
+    if (htmlDocument) {
+        htmlDocument.warnings.unshift(...(cfb.warnings || []));
+        return htmlDocument;
+    }
     const fib = parseFib(wordBytes);
     if (fib.base.wIdent !== 0xA5EC) {
         pushWarning(warnings, `Unexpected FIB identifier: 0x${fib.base.wIdent.toString(16)}`);
@@ -601,35 +666,41 @@ export function parseMsDoc(input, options = {}) {
     const clx = parseClx(tableBytes, fib.fibRgFcLcb);
     const pieceTexts = buildPieceTextCache(wordBytes, clx);
     const documentText = pieceTexts.join('');
-    const mainStoryEnd = fib.fibRgLw.ccpText > 0 ? fib.fibRgLw.ccpText : documentText.length;
+    const stories = getDocumentStoryRanges(fib, documentText.length);
+    const mainStory = stories.find((story) => story.kind === 'main') || { kind: 'main', cpStart: 0, cpEnd: documentText.length };
+    const supplementalTextStories = stories.filter((story) => ((story.kind === 'textbox' || story.kind === 'header-textbox')
+        && normalizeParagraphText(documentText.slice(story.cpStart, story.cpEnd)).replace(/[\r\u0007]/g, '').trim().length > 0));
     const styles = parseStyles(tableBytes, fib.fibRgFcLcb);
     const fonts = parseFonts(tableBytes, fib.fibRgFcLcb);
-    const chpxRuns = readChpxRuns(wordBytes, tableBytes, fib, clx).filter((run) => run.cpStart < mainStoryEnd);
+    const relevantStoryEnd = Math.max(mainStory.cpEnd, ...supplementalTextStories.map((story) => story.cpEnd));
+    const chpxRuns = readChpxRuns(wordBytes, tableBytes, fib, clx)
+        .filter((run) => run.cpStart < relevantStoryEnd)
+        .map((run) => ({ ...run, cpEnd: Math.min(run.cpEnd, relevantStoryEnd) }));
     const papxRuns = readPapxRuns(wordBytes, tableBytes, fib, clx, dataBytes)
-        .filter((run) => run.cpStart < mainStoryEnd)
-        .map((run) => ({ ...run, cpEnd: Math.min(run.cpEnd, mainStoryEnd) }));
-    const ranges = papxRuns.length
-        ? papxRuns.map((run) => ({
-            cpStart: run.cpStart,
-            cpEnd: run.cpEnd,
-            terminator: documentText[run.cpEnd - 1] || '',
-            styleId: run.styleId,
-            properties: run.properties,
-        }))
-        : splitParagraphRanges(documentText.slice(0, mainStoryEnd)).map((range) => ({ ...range, styleId: 0, properties: [] }));
+        .filter((run) => run.cpStart < relevantStoryEnd)
+        .map((run) => ({ ...run, cpEnd: Math.min(run.cpEnd, relevantStoryEnd) }));
+    const ranges = [mainStory, ...supplementalTextStories]
+        .flatMap((story) => buildStoryParagraphRanges(story, documentText, papxRuns));
+    if (supplementalTextStories.length) {
+        pushWarning(warnings, 'Recovered text from a legacy Word text-box story; text-box positioning is unavailable, so the content was linearized after the main story.', { code: 'MSDOC_TEXTBOX_STORY_LINEARIZED', storyCount: supplementalTextStories.length });
+    }
     const objectPool = extractObjectPool(cfb);
     const assets = [];
     const usedAttachmentNames = new Set();
     const assetCache = new Map();
     const resolveAsset = createAssetResolver(dataBytes, objectPool, assets, usedAttachmentNames, assetCache, options);
     const chpxCursor = { index: 0 };
-    const paragraphs = ranges.map((range) => {
+    const paragraphs = ranges.flatMap((range) => {
         const rawParagraphText = getTextByCp(wordBytes, clx, pieceTexts, range.cpStart, range.cpEnd);
         const terminator = range.terminator === DOC_CONTROL.paragraph || range.terminator === DOC_CONTROL.cellMark ? range.terminator : '';
-        const paragraphText = terminator && rawParagraphText.endsWith(terminator)
+        const rawContent = terminator && rawParagraphText.endsWith(terminator)
             ? rawParagraphText.slice(0, -1)
             : rawParagraphText;
-        return buildParagraphModel({ ...range, terminator }, paragraphText, styles, fonts, chpxRuns, resolveAsset, chpxCursor);
+        const paragraphText = normalizeParagraphText(rawContent);
+        const isTextBoxStory = range.storyKind === 'textbox' || range.storyKind === 'header-textbox';
+        if ((rawContent.includes(DOC_CONTROL.textBoxPlaceholder) || isTextBoxStory) && !paragraphText.trim())
+            return [];
+        return [buildParagraphModel({ ...range, terminator }, paragraphText, styles, fonts, chpxRuns, resolveAsset, chpxCursor)];
     });
     normalizeRowEndOnlyTables(paragraphs);
     const blocks = buildBlocks(paragraphs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/doc",
-  "version": "2.2.5",
+  "version": "2.2.7",
   "private": false,
   "type": "module",
   "description": "Browser-native legacy MS-DOC (.doc) parser and HTML renderer extracted from the public msdoc-viewer 0.2.0 line.",
@@ -70,6 +70,8 @@
     "type-check": "tsc -b tsconfig.json",
     "verify:table-spec": "pnpm build && node scripts/verify-table-spec.mjs",
     "verify:github-34": "pnpm build && node scripts/verify-github-34.mjs",
-    "verify:github-87": "pnpm build && node scripts/verify-github-87.mjs"
+    "verify:github-87": "pnpm build && node scripts/verify-github-87.mjs",
+    "verify:github-171": "pnpm build && node scripts/verify-github-171.mjs",
+    "verify:github-192": "pnpm build && node scripts/verify-github-192.mjs"
   }
 }