@file-viewer/doc 3.0.1 → 3.0.3

package/dist/msdoc/parser.js

@@ -232,11 +232,11 @@ function buildInlineNodes(segments, resolveAsset) {
                 continue;
             }
             if (ch === DOC_CONTROL.hardLineBreak) {
-                emitInline(fieldStack, output, { type: 'lineBreak' });
+                emitInline(fieldStack, output, { type: 'lineBreak', style: segment.state });
                 continue;
             }
             if (ch === DOC_CONTROL.pageBreak) {
-                emitInline(fieldStack, output, { type: 'pageBreak' });
+                emitInline(fieldStack, output, { type: 'pageBreak', style: segment.state });
                 continue;
             }
             if (ch === DOC_CONTROL.picture) {
@@ -263,6 +263,21 @@ function buildInlineNodes(segments, resolveAsset) {
     }
     return output;
 }
+function resolveCharacterFonts(state, resolveFont, defaults) {
+    for (const [id, name, fallback] of [
+        ['fontFamilyId', 'fontFamily', defaults?.ftcAsci],
+        ['fontFamilyEastAsiaId', 'fontFamilyEastAsia', defaults?.ftcFE],
+        ['fontFamilyOtherId', 'fontFamilyOther', defaults?.ftcOther],
+        ['fontFamilyBiId', 'fontFamilyBi', undefined],
+    ]) {
+        const index = state[id] ?? fallback;
+        const font = resolveFont(index);
+        if (font) {
+            state[id] = index;
+            state[name] = font.name || font.altName || undefined;
+        }
+    }
+}
 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]);
@@ -285,9 +300,7 @@ function buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps
         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;
+        resolveCharacterFonts(state, resolveFont, styles.header);
         const localStart = cpStart - range.cpStart;
         const localEnd = cpEnd - range.cpStart;
         const text = paragraphText.slice(localStart, localEnd);
@@ -305,9 +318,7 @@ function buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps
         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;
+        resolveCharacterFonts(state, resolveFont, styles.header);
         segments.push({ cpStart: range.cpStart, cpEnd: range.cpEnd, text: paragraphText, state });
     }
     return segments;
@@ -326,11 +337,20 @@ function buildParagraphModel(range, paragraphText, styles, fonts, chpxRuns, reso
     const resolveFont = (fontId) => fonts.byIndex(fontId);
     const segments = buildCharSegments(range, paragraphText, chpxRuns, styles, baseCharProps, resolveFont, chpxCursor, range.storyKind === 'textbox' || range.storyKind === 'header-textbox');
     const inlines = buildInlineNodes(segments, resolveAsset);
+    // The terminator has its own CHPX run and is not part of paragraphText.
+    const markState = range.terminator === DOC_CONTROL.paragraph
+        ? buildCharSegments({ ...range, cpStart: range.cpEnd - 1 }, range.terminator, chpxRuns, styles, baseCharProps, resolveFont, { index: chpxCursor.index })[0]?.state
+        : undefined;
     return {
         id: uniqueId('para'),
         cpStart: range.cpStart,
         cpEnd: range.cpEnd,
         terminator: range.terminator || '',
+        paragraphMark: markState && {
+            revisionDeleted: markState.revisionDeleted,
+            revisionInserted: markState.revisionInserted,
+        },
+        storyKind: range.storyKind,
         text: paragraphText,
         rawProperties: range.properties || [],
         styleId: paraStyleId,
@@ -482,6 +502,8 @@ function paragraphToBlock(paragraph) {
         paraState: paragraph.paraState,
         inlines: paragraph.inlines,
         text: paragraph.text,
+        paragraphMark: paragraph.paragraphMark,
+        storyKind: paragraph.storyKind,
     };
 }
 function tableGridSignature(paragraph) {

package/dist/msdoc/properties.js

@@ -50,6 +50,8 @@ export function charPropsToState(properties) {
                 }
                 break;
             case 'bold':
+            case 'revisionDeleted':
+            case 'revisionInserted':
             case 'italic':
             case 'strike':
             case 'hidden':
@@ -110,6 +112,7 @@ export function paraPropsToState(properties) {
         spacingBefore: 0,
         spacingAfter: 0,
         lineSpacing: 0,
+        lineSpacingRule: 'auto',
         leftIndent: 0,
         rightIndent: 0,
         firstLineIndent: 0,
@@ -150,9 +153,18 @@ export function paraPropsToState(properties) {
             case 'spacingAfter':
                 state.spacingAfter = prop.value || 0;
                 break;
-            case 'lineSpacing':
+            case 'lineSpacing': {
                 state.lineSpacing = prop.value || 0;
+                // LSPD's second short distinguishes 1/240-line multiples from signed twips.
+                const bytes = prop.operandBytes;
+                const absolute = bytes && bytes.length >= 4
+                    ? bytes[2] === 0 && bytes[3] === 0
+                    : state.lineSpacing < 0;
+                state.lineSpacingRule = absolute
+                    ? state.lineSpacing < 0 ? 'exact' : 'atLeast'
+                    : 'auto';
                 break;
+            }
             case 'leftIndent':
                 state.leftIndent = prop.value || 0;
                 break;

package/dist/msdoc/sprm.js

@@ -486,6 +486,8 @@ export function decodeSprm(sprm, operandBytes) {
     const bytes = operandBytes;
     const raw = sprm;
     switch (sprm) {
+        case SprmCodes.sprmCFRMarkDel: return setMeta('char', 'revisionDeleted', boolValue(bytes), raw, bytes);
+        case SprmCodes.sprmCFRMark: return setMeta('char', 'revisionInserted', boolValue(bytes), raw, bytes);
         case SprmCodes.sprmCPicLocation: return setMeta('char', 'pictureOffset', u32(bytes, 0) >>> 0, raw, bytes);
         case SprmCodes.sprmCFData: return setMeta('char', 'data', boolValue(bytes), raw, bytes);
         case SprmCodes.sprmCFOle2: return setMeta('char', 'ole2', boolValue(bytes), raw, bytes);
@@ -512,10 +514,10 @@ export function decodeSprm(sprm, operandBytes) {
         case SprmCodes.sprmCHpsBi: return setMeta('char', 'fontSizeHalfPoints', u16(bytes, 0), raw, bytes);
         case SprmCodes.sprmCHpsPos: return setMeta('char', 'positionHalfPoints', i16(bytes, 0), raw, bytes);
         case SprmCodes.sprmCSymbol: return setMeta('char', 'symbol', { font: u16(bytes, 0), charCode: u16(bytes, 2) }, raw, bytes);
-        case SprmCodes.sprmCRgFtc0:
-        case SprmCodes.sprmCRgFtc1:
-        case SprmCodes.sprmCRgFtc2:
-        case SprmCodes.sprmCFtcBi: return setMeta('char', 'fontFamilyId', u16(bytes, 0), raw, bytes);
+        case SprmCodes.sprmCRgFtc0: return setMeta('char', 'fontFamilyId', u16(bytes, 0), raw, bytes);
+        case SprmCodes.sprmCRgFtc1: return setMeta('char', 'fontFamilyEastAsiaId', u16(bytes, 0), raw, bytes);
+        case SprmCodes.sprmCRgFtc2: return setMeta('char', 'fontFamilyOtherId', u16(bytes, 0), raw, bytes);
+        case SprmCodes.sprmCFtcBi: return setMeta('char', 'fontFamilyBiId', u16(bytes, 0), raw, bytes);
         case SprmCodes.sprmCCharScale: return setMeta('char', 'scale', u16(bytes, 0), raw, bytes);
         case SprmCodes.sprmCFDStrike: return setMeta('char', 'doubleStrike', boolValue(bytes), raw, bytes);
         case SprmCodes.sprmCFImprint: return setMeta('char', 'imprint', boolValue(bytes), raw, bytes);

package/dist/msdoc/styles.js

@@ -179,9 +179,11 @@ export function parseStyles(tableBytes, fibRgFcLcb) {
     const stshiOffset = 2;
     const cstd = reader.u16(stshiOffset + 0);
     const cbSTDBaseInFile = reader.u16(stshiOffset + 2);
-    const ftcAsci = reader.u16(stshiOffset + 10);
-    const ftcFE = reader.u16(stshiOffset + 12);
-    const ftcOther = reader.u16(stshiOffset + 14);
+    const fontAt = (offset) => cbStshi >= offset + 2 && bytes.length >= stshiOffset + offset + 2
+        ? reader.i16(stshiOffset + offset) : -1;
+    const ftcAsci = fontAt(12);
+    const ftcFE = fontAt(14);
+    const ftcOther = fontAt(16);
     const header = { cbStshi, cstd, cbSTDBaseInFile, ftcAsci, ftcFE, ftcOther };
     let offset = 2 + cbStshi;
     const styles = new Map();

package/dist/render/fonts.d.ts

@@ -0,0 +1,5 @@
+import type { CharState } from '../types.js';
+export declare function textFontRuns(text: string, style: CharState): Array<{
+    text: string;
+    fontFamily?: string;
+}>;

package/dist/render/fonts.js

@@ -0,0 +1,25 @@
+const EAST_ASIAN = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Bopomofo}\u3000-\u303f\uff00-\uffef]/u;
+const INHERIT_FONT = /[\p{Mark}\u200c\u200d]/u;
+export function textFontRuns(text, style) {
+    if (!text)
+        return [];
+    if (style.rtl && style.fontFamilyBi)
+        return [{ text, fontFamily: style.fontFamilyBi }];
+    const base = style.fontFamily;
+    const eastAsia = style.fontFamilyEastAsia || base;
+    const other = style.fontFamilyOther || base;
+    if (eastAsia === base && other === base)
+        return [{ text, fontFamily: base }];
+    const runs = [];
+    for (const character of text) {
+        const previous = runs[runs.length - 1];
+        const fontFamily = previous && INHERIT_FONT.test(character) ? previous.fontFamily
+            : EAST_ASIAN.test(character) ? eastAsia
+                : character.codePointAt(0) < 0x80 ? base : other;
+        if (previous && previous.fontFamily === fontFamily)
+            previous.text += character;
+        else
+            runs.push({ text: character, fontFamily });
+    }
+    return runs;
+}

package/dist/render/html.js

@@ -1,6 +1,7 @@
 import { escapeHtml, slugify, twipsToPx } from '../core/utils.js';
 import { HIGHLIGHT_COLORS } from '../msdoc/constants.js';
 import { cssTextAlign, cssUnderline, cssVerticalAlign } from '../msdoc/properties.js';
+import { textFontRuns } from './fonts.js';
 const COLOR_INDEX_MAP = {
     1: '#000000',
     2: '#0000ff',
@@ -154,9 +155,14 @@ function paragraphStyleToCss(paraState) {
     if (textIndent)
         style['text-indent'] = `${textIndent}px`;
     if (paraState.lineSpacing) {
-        const lineHeight = Math.abs(paraState.lineSpacing) / 240;
-        if (lineHeight)
-            style['line-height'] = String(Math.max(1, lineHeight));
+        if (paraState.lineSpacingRule === 'exact' || paraState.lineSpacingRule === 'atLeast') {
+            style['line-height'] = `${twipsToPx(Math.abs(paraState.lineSpacing))}px`;
+        }
+        else {
+            const multiple = Math.abs(paraState.lineSpacing) / 240;
+            // A font's single line includes its metrics and leading, not just a 1em box.
+            style['line-height'] = multiple === 1 ? 'normal' : String(multiple);
+        }
     }
     if (paraState.keepLines)
         style['break-inside'] = 'avoid';
@@ -239,11 +245,30 @@ function inlineStyleToCss(styleState) {
     return style;
 }
 function renderTextNode(node, context) {
-    const content = escapeHtml(node.text);
+    if (context.reviewMode === 'final' && node.style.revisionDeleted)
+        return '';
+    if (context.reviewMode === 'original' && node.style.revisionInserted)
+        return '';
+    const content = textFontRuns(node.text, node.style).map(run => {
+        const text = escapeHtml(run.text);
+        if (!run.fontFamily || run.fontFamily === node.style.fontFamily)
+            return text;
+        const font = styleObjectToCss({ 'font-family': `${quoteCssString(run.fontFamily)},sans-serif` });
+        return `<span style="${font}">${text}</span>`;
+    }).join('');
     const inlineStyle = inlineStyleToCss(node.style);
     inlineStyle['white-space'] = 'break-spaces';
+    const revision = context.reviewMode === 'all'
+        ? node.style.revisionDeleted ? 'delete' : node.style.revisionInserted ? 'insert' : null
+        : null;
+    if (revision) {
+        inlineStyle.color = '#c62828';
+        inlineStyle['text-decoration-line'] = revision === 'delete' ? 'line-through' : 'underline';
+    }
     const style = styleObjectToCss(inlineStyle);
-    const inner = `<span${style ? ` style="${style}"` : ''}>${content}</span>`;
+    const tag = revision === 'delete' ? 'del' : revision === 'insert' ? 'ins' : 'span';
+    const change = revision ? ` data-msdoc-change="${revision}"` : '';
+    const inner = `<${tag}${change}${style ? ` style="${style}"` : ''}>${content}</${tag}>`;
     return renderLink(inner, sanitizeMsDocLinkHref(node.href, context.externalLinkPolicy));
 }
 function inlineImageDisplaySizePx(asset) {
@@ -382,6 +407,8 @@ function renderAttachmentNode(node, context) {
 }
 function renderInlineNodes(nodes, context) {
     return nodes.map((node) => {
+        if (hiddenRevision(node.style, context))
+            return '';
         if (node.type === 'text')
             return renderTextNode(node, context);
         if (node.type === 'image')
@@ -395,12 +422,37 @@ function renderInlineNodes(nodes, context) {
         return '';
     }).join('');
 }
+function hiddenRevision(revision, context) {
+    return !!((context.reviewMode === 'final' && revision?.revisionDeleted)
+        || (context.reviewMode === 'original' && revision?.revisionInserted));
+}
+function reviewParagraphs(paragraphs, context) {
+    const result = [];
+    for (const paragraph of paragraphs) {
+        const previous = result[result.length - 1];
+        if (previous && previous.storyKind === paragraph.storyKind
+            && hiddenRevision(previous.paragraphMark, context)) {
+            // The surviving paragraph mark owns the merged paragraph's formatting.
+            result[result.length - 1] = {
+                ...paragraph,
+                inlines: [...previous.inlines, ...paragraph.inlines],
+                text: previous.text + paragraph.text,
+            };
+        }
+        else {
+            result.push(paragraph);
+        }
+    }
+    return result;
+}
 function renderParagraphBlock(block, context, options = {}) {
     const tag = options.inline ? 'div' : 'p';
     const style = styleObjectToCss(paragraphStyleToCss(block.paraState));
     const body = renderInlineNodes(block.inlines || [], context);
     const empty = body || '<br>';
     const classNames = ['msdoc-paragraph'];
+    if (block.paraState.lineSpacingRule === 'atLeast')
+        classNames.push('msdoc-line-at-least');
     if (block.styleName)
         classNames.push(`msdoc-style-${slugify(block.styleName)}`);
     return `<${tag} class="${classNames.join(' ')}"${style ? ` style="${style}"` : ''}>${empty}</${tag}>`;
@@ -492,7 +544,8 @@ function renderTableBlock(block, context) {
             if ((cell.rowspan ?? 1) > 1)
                 attrs.push(` rowspan="${cell.rowspan}"`);
             const style = styleObjectToCss(cellStyle(cell));
-            const body = cell.paragraphs.map((paragraph) => renderParagraphBlock(paragraph, context, { inline: true })).join('');
+            const body = reviewParagraphs(cell.paragraphs, context)
+                .map((paragraph) => renderParagraphBlock(paragraph, context, { inline: true })).join('');
             return `<td class="msdoc-cell"${attrs.join('')}${style ? ` style="${style}"` : ''}>${body || '<div class="msdoc-paragraph"><br></div>'}</td>`;
         })
             .join('');
@@ -516,6 +569,7 @@ export function defaultMsDocCss() {
 .msdoc-root{box-sizing:border-box;max-width:100%;padding:24px;background:#fff;color:#111;font:14px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
 .msdoc-root *{box-sizing:border-box}
 .msdoc-paragraph{margin:0 0 8px;white-space:normal;word-break:break-word;overflow-wrap:anywhere}
+.msdoc-line-at-least span,.msdoc-line-at-least ins,.msdoc-line-at-least del{line-height:normal}
 .msdoc-paragraph:last-child{margin-bottom:0}
 .msdoc-table{margin:12px 0;border-collapse:collapse;border-spacing:0;max-width:100%}
 .msdoc-cell{padding:6px 8px;vertical-align:top;word-break:break-word;overflow-wrap:anywhere}
@@ -537,18 +591,29 @@ export function defaultMsDocCss() {
 export function renderMsDoc(parsed, options = {}) {
     const css = options.css ?? defaultMsDocCss();
     const context = {
+        reviewMode: options.reviewMode ?? 'all',
         externalLinkPolicy: options.externalLinkPolicy ?? 'block',
         externalResourcePolicy: options.externalResourcePolicy ?? 'block',
     };
-    const html = parsed.blocks.map((block) => {
-        if (block.type === 'paragraph')
-            return renderParagraphBlock(block, context);
+    const parts = [];
+    let paragraphs = [];
+    const flushParagraphs = () => {
+        parts.push(...reviewParagraphs(paragraphs, context).map(block => renderParagraphBlock(block, context)));
+        paragraphs = [];
+    };
+    for (const block of parsed.blocks) {
+        if (block.type === 'paragraph') {
+            paragraphs.push(block);
+            continue;
+        }
+        flushParagraphs();
         if (block.type === 'table')
-            return renderTableBlock(block, context);
+            parts.push(renderTableBlock(block, context));
         if (block.type === 'attachments')
-            return renderAttachmentsBlock(block);
-        return '';
-    }).join('');
+            parts.push(renderAttachmentsBlock(block));
+    }
+    flushParagraphs();
+    const html = parts.join('');
     return {
         html,
         css,

package/dist/types.d.ts

@@ -246,6 +246,8 @@ export interface SymbolInfo {
     [key: string]: unknown;
 }
 export interface CharState {
+    revisionDeleted?: boolean;
+    revisionInserted?: boolean;
     bold: boolean;
     italic: boolean;
     strike: boolean;
@@ -253,6 +255,12 @@ export interface CharState {
     fontSizeHalfPoints?: number;
     fontFamilyId?: number;
     fontFamily?: string;
+    fontFamilyEastAsiaId?: number;
+    fontFamilyEastAsia?: string;
+    fontFamilyOtherId?: number;
+    fontFamilyOther?: string;
+    fontFamilyBiId?: number;
+    fontFamilyBi?: string;
     colorIndex?: number;
     highlight?: HighlightInfo | number;
     spacing: number;
@@ -293,6 +301,7 @@ export interface ParaState {
     spacingBefore: number;
     spacingAfter: number;
     lineSpacing: number;
+    lineSpacingRule?: 'auto' | 'atLeast' | 'exact';
     leftIndent: number;
     rightIndent: number;
     firstLineIndent: number;
@@ -552,9 +561,11 @@ export interface AttachmentInlineNode {
 }
 export interface LineBreakInlineNode {
     type: 'lineBreak';
+    style?: CharState;
 }
 export interface PageBreakInlineNode {
     type: 'pageBreak';
+    style?: CharState;
 }
 export type InlineNode = TextInlineNode | ImageInlineNode | AttachmentInlineNode | LineBreakInlineNode | PageBreakInlineNode;
 export interface ParagraphBlock {
@@ -565,6 +576,8 @@ export interface ParagraphBlock {
     paraState: ParaState;
     inlines: InlineNode[];
     text: string;
+    paragraphMark?: Pick<CharState, 'revisionDeleted' | 'revisionInserted'>;
+    storyKind?: string;
 }
 export interface TableCellBlock {
     id: string;
@@ -600,6 +613,8 @@ export interface ParagraphModel {
     cpStart: number;
     cpEnd: number;
     terminator: string;
+    paragraphMark?: Pick<CharState, 'revisionDeleted' | 'revisionInserted'>;
+    storyKind?: string;
     text: string;
     rawProperties: DecodedProperty[];
     styleId: number;
@@ -617,6 +632,8 @@ export interface MsDocParseOptions {
 }
 export interface MsDocRenderOptions {
     css?: string;
+    /** Preserve insertion/deletion marks by default; explicitly select final or original text. */
+    reviewMode?: 'all' | 'final' | 'original';
     /** External links are blocked by default; internal document bookmarks remain active. */
     externalLinkPolicy?: 'allow' | 'block';
     /** Linked image resources are blocked by default; embedded data/blob images remain available. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/doc",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "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.",
@@ -27,12 +27,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/flyfish-dev/docjs.git",
+    "url": "git+https://github.com/flyfish-dev/file-viewer.git",
     "directory": "packages/renderers/doc"
   },
   "homepage": "https://github.com/flyfish-dev/docjs",
   "bugs": {
-    "url": "https://github.com/flyfish-dev/docjs/issues"
+    "url": "https://github.com/flyfish-dev/file-viewer/issues"
   },
   "funding": {
     "type": "individual",
@@ -62,7 +62,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "dompurify": "^3.4.14"
+    "dompurify": "3.4.15"
   },
   "devDependencies": {
     "typescript": "^6.0.3"