@file-viewer/doc 2.1.26 → 2.1.28

package/dist/msdoc/parser.d.ts

@@ -1,4 +1,6 @@
-import type { MsDocParseOptions, MsDocParseResult } from '../types.js';
+import type { MsDocParseOptions, MsDocParseResult, ParagraphModel, TableRowBlock } from '../types.js';
+export declare function finalizeTableGrid(rows: TableRowBlock[]): void;
+export declare function normalizeRowEndOnlyTables(paragraphs: ParagraphModel[]): void;
 /**
  * Main MS-DOC entry point.
  * It parses the OLE container, restores text through the piece table, resolves

package/dist/msdoc/parser.js

@@ -283,26 +283,41 @@ function buildParagraphModel(range, paragraphText, styles, fonts, chpxRuns, reso
         inlines,
     };
 }
-function finalizeTableGrid(rows) {
+export function finalizeTableGrid(rows) {
     for (const row of rows) {
-        for (let i = 0; i < row.cells.length; i += 1) {
-            const cell = row.cells[i];
-            const merge = cell.meta?.merge || 0;
-            cell.colIndex = i;
+        row.cells.forEach((cell, index) => {
+            cell.colIndex = index;
             cell.colspan = 1;
             cell.rowspan = 1;
             cell.hidden = false;
+        });
+        for (let i = 0; i < row.cells.length; i += 1) {
+            const cell = row.cells[i];
+            const merge = cell.meta?.merge || 0;
             if (merge === 1) {
-                cell.hidden = true;
                 continue;
             }
             if (merge > 1) {
                 let j = i + 1;
                 while (j < row.cells.length && (row.cells[j].meta?.merge || 0) === 1) {
                     row.cells[j].hidden = true;
-                    cell.colspan += 1;
+                    cell.colspan = (cell.colspan || 1) + 1;
                     j += 1;
                 }
+                const lastCell = row.cells[j - 1];
+                if (cell.meta && lastCell?.meta && lastCell !== cell) {
+                    cell.meta.rightBoundary = lastCell.meta.rightBoundary;
+                    if (cell.meta.leftBoundary != null && cell.meta.rightBoundary != null) {
+                        cell.meta.width = Math.max(0, cell.meta.rightBoundary - cell.meta.leftBoundary);
+                    }
+                    const rightBorder = lastCell.meta.borders?.right;
+                    if (rightBorder) {
+                        cell.meta.borders = {
+                            ...(cell.meta.borders || {}),
+                            right: rightBorder,
+                        };
+                    }
+                }
             }
         }
     }
@@ -313,7 +328,6 @@ function finalizeTableGrid(rows) {
                 continue;
             const vertMerge = cell.meta?.vertMerge || 0;
             if (vertMerge === 1) {
-                cell.hidden = true;
                 continue;
             }
             if (vertMerge > 1) {
@@ -335,9 +349,69 @@ function finalizeTableGrid(rows) {
                     cell.rowspan = (cell.rowspan || 1) + 1;
                     nextIndex += 1;
                 }
+                const bottomCell = rows[nextIndex - 1]?.cells[cell.colIndex || 0];
+                const bottomBorder = bottomCell?.meta?.borders?.bottom;
+                if (cell.meta && bottomCell?.meta && bottomCell !== cell && bottomBorder) {
+                    cell.meta.borders = {
+                        ...(cell.meta.borders || {}),
+                        bottom: bottomBorder,
+                    };
+                }
             }
         }
     }
+    // HTML tables need one shared column grid even when Word stores a different
+    // TDefTable boundary list per row (usually because cells are merged). Map
+    // every visible cell back onto the union of physical boundaries so colspan
+    // preserves the original geometry instead of squeezing later row cells.
+    const boundaries = Array.from(new Set(rows.flatMap((row) => row.cells.flatMap((cell) => {
+        const left = cell.meta?.leftBoundary;
+        const right = cell.meta?.rightBoundary;
+        return [left, right].filter((value) => value != null);
+    })))).sort((left, right) => left - right);
+    if (boundaries.length > 1) {
+        for (const row of rows) {
+            for (const cell of row.cells) {
+                if (!cell.meta)
+                    continue;
+                const leftIndex = boundaries.indexOf(cell.meta.leftBoundary ?? Number.NaN);
+                const rightIndex = boundaries.indexOf(cell.meta.rightBoundary ?? Number.NaN);
+                if (leftIndex >= 0)
+                    cell.colIndex = leftIndex;
+                if (!cell.hidden && leftIndex >= 0 && rightIndex > leftIndex) {
+                    cell.colspan = rightIndex - leftIndex;
+                }
+            }
+        }
+    }
+}
+function resolveTableGridBorders(rows) {
+    const hasOwnBorder = (borders, side) => (Object.prototype.hasOwnProperty.call(borders, side) && (() => {
+        const border = borders[side];
+        // An all-zero BRC is an empty cell-level value and still inherits the
+        // table edge/inside border. NilBrc is the explicit "no border" value.
+        return Boolean(border?.nil || border?.borderType);
+    })());
+    rows.forEach((row, rowIndex) => {
+        row.cells.forEach((cell) => {
+            if (cell.hidden || !cell.meta)
+                return;
+            const explicit = { ...(cell.meta.borders || {}) };
+            const table = row.state.borders || {};
+            const startColumn = cell.colIndex || 0;
+            const endColumn = startColumn + (cell.colspan || 1);
+            const endRow = rowIndex + (cell.rowspan || 1);
+            const assignFallback = (side, border) => {
+                if (!hasOwnBorder(explicit, side) && border)
+                    explicit[side] = border;
+            };
+            assignFallback('top', rowIndex === 0 ? table.top : table.horizontalInside);
+            assignFallback('bottom', endRow >= rows.length ? table.bottom : table.horizontalInside);
+            assignFallback('left', startColumn === 0 ? table.left : table.verticalInside);
+            assignFallback('right', endColumn >= row.cells.length ? table.right : table.verticalInside);
+            cell.meta.borders = explicit;
+        });
+    });
 }
 function paragraphToBlock(paragraph) {
     return {
@@ -350,27 +424,79 @@ function paragraphToBlock(paragraph) {
         text: paragraph.text,
     };
 }
-function normalizeRowEndOnlyTables(paragraphs) {
+function tableGridSignature(paragraph) {
+    const cells = applyTableStateToCells(paragraph.tableState);
+    if (!cells.length)
+        return '';
+    const state = paragraph.tableState;
+    const border = (side) => {
+        const value = state.borders?.[side];
+        return `${value?.borderType ?? ''}:${value?.lineWidth ?? ''}:${value?.nil ? 1 : 0}`;
+    };
+    return [
+        cells[0]?.leftBoundary ?? '',
+        cells[cells.length - 1]?.rightBoundary ?? '',
+        state.alignment ?? '',
+        state.leftIndent ?? '',
+        state.gapHalf ?? '',
+        state.rtl ? 1 : 0,
+        border('top'),
+        border('left'),
+        border('bottom'),
+        border('right'),
+        border('horizontalInside'),
+        border('verticalInside'),
+    ].join('|');
+}
+function inheritRowEndTableState(paragraph, rowEnd) {
+    paragraph.paraState.inTable = true;
+    paragraph.paraState.itap = Math.max(rowEnd.paraState.itap || 1, paragraph.paraState.itap || 0);
+    paragraph.tableState = rowEnd.tableState;
+    paragraph.tableProps = rowEnd.tableProps;
+}
+export function normalizeRowEndOnlyTables(paragraphs) {
     for (let index = 0; index < paragraphs.length; index += 1) {
         const rowEnd = paragraphs[index];
-        const cellCount = rowEnd.tableState.defTable?.cells?.length || 0;
+        const cellCount = applyTableStateToCells(rowEnd.tableState).length;
         if (!rowEnd.paraState.tableRowEnd || !cellCount)
             continue;
         rowEnd.paraState.inTable = true;
         rowEnd.paraState.itap = Math.max(1, rowEnd.paraState.itap || 0);
         let remainingCells = cellCount;
-        for (let cursor = index - 1; cursor >= 0 && remainingCells > 0; cursor -= 1) {
+        let cursor = index - 1;
+        const rowParagraphs = [];
+        for (; cursor >= 0 && remainingCells > 0; cursor -= 1) {
             const paragraph = paragraphs[cursor];
             if (paragraph.paraState.tableRowEnd || paragraph.paraState.innerTableRowEnd)
                 break;
-            if (paragraph.terminator !== DOC_CONTROL.cellMark)
-                break;
-            paragraph.paraState.inTable = true;
-            paragraph.paraState.itap = Math.max(rowEnd.paraState.itap || 1, paragraph.paraState.itap || 0);
-            paragraph.tableState = rowEnd.tableState;
-            paragraph.tableProps = rowEnd.tableProps;
-            remainingCells -= 1;
+            rowParagraphs.push(paragraph);
+            if (paragraph.terminator === DOC_CONTROL.cellMark)
+                remainingCells -= 1;
+        }
+        if (remainingCells > 0)
+            continue;
+        // Some Word/WPS producers store all table properties only on the row-end
+        // PAPX. Paragraph marks inside a cell then look like ordinary paragraphs.
+        // When the immediately preceding row has the same outer grid and table
+        // border identity, everything between the two row terminators belongs to
+        // the current row, including leading paragraphs in its first cell.
+        let previousRowEndIndex = cursor;
+        while (previousRowEndIndex >= 0
+            && !paragraphs[previousRowEndIndex].paraState.tableRowEnd
+            && !paragraphs[previousRowEndIndex].paraState.innerTableRowEnd
+            && paragraphs[previousRowEndIndex].terminator !== DOC_CONTROL.cellMark) {
+            previousRowEndIndex -= 1;
+        }
+        const previousRowEnd = paragraphs[previousRowEndIndex];
+        if (previousRowEnd?.paraState.tableRowEnd
+            && tableGridSignature(previousRowEnd) === tableGridSignature(rowEnd)) {
+            for (let leading = previousRowEndIndex + 1; leading < index; leading += 1) {
+                const paragraph = paragraphs[leading];
+                if (!rowParagraphs.includes(paragraph))
+                    rowParagraphs.push(paragraph);
+            }
         }
+        rowParagraphs.forEach((paragraph) => inheritRowEndTableState(paragraph, rowEnd));
     }
 }
 function buildTableBlock(tableParagraphs) {
@@ -416,6 +542,7 @@ function buildTableBlock(tableParagraphs) {
         rows.push({ id: uniqueId('row'), cells: pendingRow.cells, state: tableParagraphs[0]?.tableState || tablePropsToState([]), gridWidthTwips: 0 });
     }
     finalizeTableGrid(rows);
+    resolveTableGridBorders(rows);
     const gridWidthTwips = rows.find((row) => row.gridWidthTwips)?.gridWidthTwips || 0;
     const depth = Math.max(...tableParagraphs.map((paragraph) => getTableDepth(paragraph.paraState)), 1);
     return {

package/dist/msdoc/properties.js

@@ -251,6 +251,7 @@ export function tablePropsToState(properties) {
         autoFit: undefined,
         widthBefore: undefined,
         widthAfter: undefined,
+        borders: {},
         defTable: undefined,
         operations: [],
     };
@@ -303,6 +304,9 @@ export function tablePropsToState(properties) {
             case 'widthAfter':
                 state.widthAfter = prop.value;
                 break;
+            case 'tableBorders':
+                state.borders = prop.value || {};
+                break;
             case 'defTable':
                 state.defTable = prop.value;
                 break;
@@ -337,11 +341,11 @@ export function rangeApply(list, range, callback) {
 }
 export function applyTableStateToCells(tableState) {
     const def = tableState?.defTable;
-    if (!def || !Array.isArray(def.cells))
-        return [];
-    const cells = def.cells.map((cell, index) => ({
+    const cells = (def?.cells || []).map((cell, index) => ({
         index,
-        width: cell?.wWidth,
+        width: def?.rgdxaCenter?.[index + 1] != null && def?.rgdxaCenter?.[index] != null
+            ? Math.max(0, def.rgdxaCenter[index + 1] - def.rgdxaCenter[index])
+            : cell?.wWidth,
         ftsWidth: cell?.tcgrf?.ftsWidth,
         borders: (cell?.borders || {}),
         merge: cell?.tcgrf?.horzMerge || 0,
@@ -351,11 +355,52 @@ export function applyTableStateToCells(tableState) {
         noWrap: Boolean(cell?.tcgrf?.noWrap),
         hideMark: Boolean(cell?.tcgrf?.hideMark),
         textFlow: cell?.tcgrf?.textFlow || 0,
-        rightBoundary: def.rgdxaCenter?.[index + 1],
-        leftBoundary: def.rgdxaCenter?.[index],
+        rightBoundary: def?.rgdxaCenter?.[index + 1],
+        leftBoundary: def?.rgdxaCenter?.[index],
     }));
+    let geometryChanged = false;
+    const initialLeftBoundary = cells[0]?.leftBoundary || 0;
     for (const op of tableState.operations || []) {
         switch (op.name) {
+            case 'insertCells': {
+                // Word commonly emits TDefTable for legacy readers and TInsert for
+                // readers that process sprmPTableProps. They are alternative cell
+                // definitions, not cumulative instructions.
+                if (def?.cells?.length)
+                    break;
+                const value = op.value;
+                const first = Math.min(cells.length, Math.max(0, value?.itcFirst || 0));
+                const count = Math.min(63 - cells.length, Math.max(0, value?.ctc || 0));
+                const width = Math.max(0, value?.dxaCol || 0);
+                if (count) {
+                    cells.splice(first, 0, ...Array.from({ length: count }, (_, offset) => ({
+                        index: first + offset,
+                        width,
+                        borders: {},
+                        merge: 0,
+                        vertMerge: 0,
+                        vertAlign: 0,
+                        fitText: false,
+                        noWrap: false,
+                        hideMark: false,
+                        textFlow: 0,
+                    })));
+                    geometryChanged = true;
+                }
+                break;
+            }
+            case 'deleteCells': {
+                const range = op.value;
+                if (range) {
+                    const first = Math.max(0, range.first || 0);
+                    const count = Math.max(0, (range.lim || first) - first);
+                    if (count) {
+                        cells.splice(first, count);
+                        geometryChanged = true;
+                    }
+                }
+                break;
+            }
             case 'merge':
                 rangeApply(cells, op.value, (cell, idx) => {
                     const range = op.value;
@@ -369,25 +414,88 @@ export function applyTableStateToCells(tableState) {
                 rangeApply(cells, op.value, (cell) => { cell.merge = 0; });
                 break;
             case 'cellWidth':
-            case 'columnWidth':
                 rangeApply(cells, op.value.range, (cell) => {
                     const value = op.value;
-                    cell.width = value.width;
                     cell.ftsWidth = value.ftsWidth;
+                    // ftsNil and ftsAuto carry no usable preferred width. Preserve the
+                    // TDefTable boundary width instead of collapsing the cell to zero.
+                    if ((value.ftsWidth === 2 || value.ftsWidth === 3) && value.width != null) {
+                        cell.width = value.width;
+                    }
+                });
+                break;
+            case 'columnWidth':
+                rangeApply(cells, op.value.range, (cell) => {
+                    cell.width = Math.max(0, op.value.width || 0);
+                    geometryChanged = true;
                 });
                 break;
-            case 'vertMerge':
-                rangeApply(cells, op.value.range, (cell) => { cell.vertMerge = op.value.value; });
+            case 'vertMerge': {
+                const value = op.value;
+                const cell = value?.index != null ? cells[value.index] : undefined;
+                if (cell)
+                    cell.vertMerge = value?.value || 0;
                 break;
+            }
             case 'vertAlign':
                 rangeApply(cells, op.value.range, (cell) => { cell.vertAlign = op.value.value; });
                 break;
             case 'setBorder':
-                rangeApply(cells, op.value.range, (cell) => { cell.borders = { ...(cell.borders || {}), all: op.value.border }; });
+                rangeApply(cells, op.value.range, (cell) => {
+                    const value = op.value;
+                    const borders = { ...(cell.borders || {}) };
+                    if (value.bordersToApply & 0x01)
+                        borders.top = value.border;
+                    if (value.bordersToApply & 0x02)
+                        borders.left = value.border;
+                    if (value.bordersToApply & 0x04)
+                        borders.bottom = value.border;
+                    if (value.bordersToApply & 0x08)
+                        borders.right = value.border;
+                    if (value.bordersToApply & 0x10)
+                        borders.diagonalDown = value.border;
+                    if (value.bordersToApply & 0x20)
+                        borders.diagonalUp = value.border;
+                    cell.borders = borders;
+                });
                 break;
             case 'setShading':
-                rangeApply(cells, op.value.range, (cell) => { cell.shading = op.value.value; });
+                rangeApply(cells, op.value.range, (cell, index) => {
+                    const value = op.value;
+                    if (!value.odd || (index - value.range.first) % 2 === 0)
+                        cell.shading = value.shading;
+                });
                 break;
+            case 'cellPadding':
+            case 'cellSpacing': {
+                const value = op.value;
+                const isTwips = value?.ftsWidth === 3 || (op.name === 'cellSpacing' && value?.ftsWidth === 0x13);
+                if (!value?.range || !isTwips || value.width == null)
+                    break;
+                rangeApply(cells, value.range, (cell) => {
+                    const key = op.name === 'cellPadding' ? 'paddingTwips' : 'spacingTwips';
+                    const sides = { ...(cell[key] || {}) };
+                    if ((value.sides || 0) & 0x01)
+                        sides.top = value.width;
+                    if ((value.sides || 0) & 0x02)
+                        sides.left = value.width;
+                    if ((value.sides || 0) & 0x04)
+                        sides.bottom = value.width;
+                    if ((value.sides || 0) & 0x08)
+                        sides.right = value.width;
+                    cell[key] = sides;
+                });
+                break;
+            }
+            case 'defaultShading': {
+                const value = op.value;
+                (value?.values || []).forEach((shading, offset) => {
+                    const cell = cells[(value?.start || 0) + offset];
+                    if (cell)
+                        cell.shading = shading;
+                });
+                break;
+            }
             case 'fitText':
                 rangeApply(cells, op.value.range, (cell) => { cell.fitText = Boolean(op.value.value); });
                 break;
@@ -401,5 +509,15 @@ export function applyTableStateToCells(tableState) {
                 break;
         }
     }
+    if (geometryChanged) {
+        let boundary = initialLeftBoundary;
+        cells.forEach((cell) => {
+            const width = Math.max(0, cell.width || 0);
+            cell.leftBoundary = boundary;
+            boundary += width;
+            cell.rightBoundary = boundary;
+        });
+    }
+    cells.forEach((cell, index) => { cell.index = index; });
     return cells;
 }

package/dist/msdoc/sprm.d.ts

@@ -126,6 +126,7 @@ export declare const SprmCodes: {
     readonly sprmTTableBorders: 54803;
     readonly sprmTTableWidth: 62996;
     readonly sprmTFAutofit: 13845;
+    readonly sprmTDefTableShd2nd: 54806;
     readonly sprmTWidthBefore: 62999;
     readonly sprmTWidthAfter: 63000;
     readonly sprmTSetBrc80: 54816;
@@ -141,11 +142,15 @@ export declare const SprmCodes: {
     readonly sprmTSetShdOdd: 54830;
     readonly sprmTSetBrc: 54831;
     readonly sprmTCellPadding: 54834;
-    readonly sprmTCellPaddingDefault: 54835;
+    readonly sprmTCellSpacingDefault: 54835;
+    readonly sprmTCellPaddingDefault: 54836;
     readonly sprmTCellWidth: 54837;
     readonly sprmTFitText: 63030;
     readonly sprmTFCellNoWrap: 54841;
     readonly sprmTIstd: 22074;
+    readonly sprmTDefTableShdRaw: 54896;
+    readonly sprmTDefTableShdRaw2nd: 54897;
+    readonly sprmTDefTableShdRaw3rd: 54898;
 };
 export declare function getSprmGroup(sprm: number): number;
 export declare function getSprmOperandLength(buffer: Uint8Array, offset: number, sprm: number): number;

package/dist/msdoc/sprm.js

@@ -126,6 +126,7 @@ export const SprmCodes = {
     sprmTTableBorders: 0xd613,
     sprmTTableWidth: 0xf614,
     sprmTFAutofit: 0x3615,
+    sprmTDefTableShd2nd: 0xd616,
     sprmTWidthBefore: 0xf617,
     sprmTWidthAfter: 0xf618,
     sprmTSetBrc80: 0xd620,
@@ -141,11 +142,15 @@ export const SprmCodes = {
     sprmTSetShdOdd: 0xd62e,
     sprmTSetBrc: 0xd62f,
     sprmTCellPadding: 0xd632,
-    sprmTCellPaddingDefault: 0xd633,
+    sprmTCellSpacingDefault: 0xd633,
+    sprmTCellPaddingDefault: 0xd634,
     sprmTCellWidth: 0xd635,
     sprmTFitText: 0xf636,
     sprmTFCellNoWrap: 0xd639,
     sprmTIstd: 0x563a,
+    sprmTDefTableShdRaw: 0xd670,
+    sprmTDefTableShdRaw2nd: 0xd671,
+    sprmTDefTableShdRaw3rd: 0xd672,
 };
 const VARIABLE_OPERAND_CODES = new Set([
     SprmCodes.sprmPChgTabs,
@@ -156,17 +161,20 @@ const VARIABLE_OPERAND_CODES = new Set([
     SprmCodes.sprmTDefTableShd,
     SprmCodes.sprmTDefTableShd80,
     SprmCodes.sprmTDefTableShd3rd,
+    SprmCodes.sprmTDefTableShd2nd,
+    SprmCodes.sprmTDefTableShdRaw,
+    SprmCodes.sprmTDefTableShdRaw2nd,
+    SprmCodes.sprmTDefTableShdRaw3rd,
     SprmCodes.sprmTSetBrc80,
     SprmCodes.sprmTSetBrc,
     SprmCodes.sprmTSetShd,
     SprmCodes.sprmTSetShdOdd,
     SprmCodes.sprmTCellPadding,
+    SprmCodes.sprmTCellSpacingDefault,
     SprmCodes.sprmTCellPaddingDefault,
     SprmCodes.sprmTCellWidth,
     SprmCodes.sprmTVertAlign,
     SprmCodes.sprmTVertMerge,
-    SprmCodes.sprmTTextFlow,
-    SprmCodes.sprmTDxaCol,
 ]);
 export function getSprmGroup(sprm) {
     return (sprm >> 13) & 0x7;
@@ -198,10 +206,38 @@ function parseBrc80(bytes, offset = 0) {
     if (offset + 4 > bytes.length)
         return null;
     const brc = u32(bytes, offset) >>> 0;
+    if (brc === 0xffffffff)
+        return { raw: brc, nil: true };
     const lineWidth = brc & 0xff;
     const borderType = (brc >> 8) & 0xff;
     const color = (brc >> 16) & 0xff;
-    return { raw: brc, lineWidth, borderType, color };
+    const flags = (brc >>> 24) & 0xff;
+    return {
+        raw: brc,
+        lineWidth,
+        borderType,
+        color,
+        space: flags & 0x1f,
+        shadow: Boolean(flags & 0x20),
+        frame: Boolean(flags & 0x40),
+    };
+}
+function parseBrc(bytes, offset = 0) {
+    if (offset + 8 > bytes.length)
+        return null;
+    const colorRef = u32(bytes, offset) >>> 0;
+    const packed = u32(bytes, offset + 4) >>> 0;
+    if (packed === 0xffffffff)
+        return { raw: packed, colorRef, nil: true };
+    return {
+        raw: packed,
+        colorRef,
+        lineWidth: packed & 0xff,
+        borderType: (packed >>> 8) & 0xff,
+        space: (packed >>> 16) & 0x1f,
+        shadow: Boolean(packed & (1 << 21)),
+        frame: Boolean(packed & (1 << 22)),
+    };
 }
 function parseTcgrf(bytes, offset = 0) {
     const value = u16(bytes, offset);
@@ -231,6 +267,63 @@ function parseTc80(bytes, offset = 0) {
         },
     };
 }
+function parseShd80(bytes, offset = 0) {
+    if (offset + 2 > bytes.length)
+        return null;
+    const raw = u16(bytes, offset);
+    const foregroundColorIndex = raw & 0x1f;
+    const backgroundColorIndex = (raw >>> 5) & 0x1f;
+    const pattern = (raw >>> 10) & 0x3f;
+    return {
+        foregroundColorIndex,
+        backgroundColorIndex,
+        pattern,
+        auto: pattern === 0,
+        nil: raw === 0xffff,
+        legacy: true,
+    };
+}
+function parseShd(bytes, offset = 0) {
+    if (offset + 10 > bytes.length)
+        return null;
+    const foregroundColorRef = u32(bytes, offset) >>> 0;
+    const backgroundColorRef = u32(bytes, offset + 4) >>> 0;
+    const pattern = u16(bytes, offset + 8);
+    return {
+        foregroundColorRef,
+        backgroundColorRef,
+        pattern,
+        auto: pattern === 0,
+        nil: pattern === 0xffff,
+    };
+}
+function parseTableBorders(bytes, legacy) {
+    const borderSize = legacy ? 4 : 8;
+    if (!bytes.length || bytes.length < 1 + borderSize * 6)
+        return null;
+    const parse = legacy ? parseBrc80 : parseBrc;
+    const names = [
+        'top', 'left', 'bottom', 'right', 'horizontalInside', 'verticalInside',
+    ];
+    const borders = {};
+    names.forEach((name, index) => {
+        const border = parse(bytes, 1 + index * borderSize);
+        if (border)
+            borders[name] = border;
+    });
+    return borders;
+}
+function parseDefaultShading(bytes, start, legacy) {
+    const size = legacy ? 2 : 10;
+    const count = Math.floor(Math.min(bytes[0] ?? 0, Math.max(0, bytes.length - 1)) / size);
+    const values = [];
+    for (let index = 0; index < count; index += 1) {
+        const shading = legacy ? parseShd80(bytes, 1 + index * size) : parseShd(bytes, 1 + index * size);
+        if (shading)
+            values.push(shading);
+    }
+    return { start, values };
+}
 function parseTDefTableOperand(bytes) {
     if (bytes.length < 3)
         return null;
@@ -275,16 +368,67 @@ function parseRangeWidthOperand(bytes) {
         wWidth: width,
     };
 }
+function parseCssaOperand(bytes) {
+    if (bytes.length < 7)
+        return null;
+    const width = u16(bytes, 5);
+    return {
+        cb: bytes[0] ?? 0,
+        range: parseItcFirstLim(bytes, 1),
+        sides: bytes[3] ?? 0,
+        ftsWidth: bytes[4] ?? 0,
+        width,
+        wWidth: width,
+    };
+}
 function parseRangeBrcOperand(bytes) {
-    if (!bytes.length)
+    if (bytes.length < 8)
+        return null;
+    return {
+        cb: bytes[0] ?? 0,
+        range: parseItcFirstLim(bytes, 1),
+        bordersToApply: bytes[3] ?? 0,
+        border: parseBrc80(bytes, 4) || { nil: true },
+        extra: bytes.subarray(8),
+    };
+}
+function parseRangeBrcOperand97(bytes) {
+    if (bytes.length < 12)
         return null;
     return {
         cb: bytes[0] ?? 0,
         range: parseItcFirstLim(bytes, 1),
-        border: parseBrc80(bytes, 3) || {},
-        extra: bytes.subarray(7),
+        bordersToApply: bytes[3] ?? 0,
+        border: parseBrc(bytes, 4) || { nil: true },
+        extra: bytes.subarray(12),
     };
 }
+function parseTableShadeOperand(bytes, odd = false) {
+    if (bytes.length < 13)
+        return null;
+    return {
+        cb: bytes[0] ?? 0,
+        range: parseItcFirstLim(bytes, 1),
+        shading: parseShd(bytes, 3),
+        odd,
+    };
+}
+function parseVertMergeOperand(bytes) {
+    if (bytes.length < 3)
+        return null;
+    return { cb: bytes[0] ?? 0, index: bytes[1] ?? 0, value: bytes[2] ?? 0 };
+}
+function parseFixedRangeValueOperand(bytes) {
+    if (bytes.length < 3)
+        return null;
+    return { range: parseItcFirstLim(bytes, 0), value: bytes[2] ?? 0 };
+}
+function parseFixedRangeWidthOperand(bytes) {
+    if (bytes.length < 4)
+        return null;
+    const width = i16(bytes, 2);
+    return { range: parseItcFirstLim(bytes, 0), width, wWidth: width };
+}
 function parseTTableWidth(bytes) {
     if (!bytes.length)
         return null;
@@ -296,23 +440,13 @@ function parseTTableWidth(bytes) {
     };
 }
 function parseTInsertOperand(bytes) {
-    if (!bytes.length)
+    if (bytes.length < 4)
         return null;
-    const cb = bytes[0] ?? 0;
-    const itc = parseItcFirstLim(bytes, 1);
-    const ctc = itc.lim - itc.first;
-    let offset = 3;
-    const dxaCol = [];
-    for (let i = 0; i < ctc && offset + 2 <= bytes.length; i += 1) {
-        dxaCol.push(i16(bytes, offset));
-        offset += 2;
-    }
-    const cells = [];
-    for (let i = 0; i < ctc && offset + 20 <= bytes.length; i += 1) {
-        cells.push(parseTc80(bytes, offset));
-        offset += 20;
-    }
-    return { cb, range: itc, itcFirst: itc.first, ctc, dxaCol, cells };
+    return {
+        itcFirst: bytes[0] ?? 0,
+        ctc: bytes[1] ?? 0,
+        dxaCol: u16(bytes, 2),
+    };
 }
 export function getSprmOperandLength(buffer, offset, sprm) {
     const spra = (sprm >> 13) & 0x7;
@@ -415,18 +549,18 @@ export function decodeSprm(sprm, operandBytes) {
         case SprmCodes.sprmPDxaWidth: return setMeta('para', 'frameWidth', i16(bytes, 0), raw, bytes);
         case SprmCodes.sprmPPc: return setMeta('para', 'framePosition', bytes[0] ?? 0, raw, bytes);
         case SprmCodes.sprmPWr: return setMeta('para', 'frameWrap', bytes[0] ?? 0, raw, bytes);
-        case SprmCodes.sprmPBrcTop80:
-        case SprmCodes.sprmPBrcTop: return setMeta('para', 'borderTop', parseBrc80(bytes, 0), raw, bytes);
-        case SprmCodes.sprmPBrcLeft80:
-        case SprmCodes.sprmPBrcLeft: return setMeta('para', 'borderLeft', parseBrc80(bytes, 0), raw, bytes);
-        case SprmCodes.sprmPBrcBottom80:
-        case SprmCodes.sprmPBrcBottom: return setMeta('para', 'borderBottom', parseBrc80(bytes, 0), raw, bytes);
-        case SprmCodes.sprmPBrcRight80:
-        case SprmCodes.sprmPBrcRight: return setMeta('para', 'borderRight', parseBrc80(bytes, 0), raw, bytes);
-        case SprmCodes.sprmPBrcBetween80:
-        case SprmCodes.sprmPBrcBetween: return setMeta('para', 'borderBetween', parseBrc80(bytes, 0), raw, bytes);
-        case SprmCodes.sprmPBrcBar80:
-        case SprmCodes.sprmPBrcBar: return setMeta('para', 'borderBar', parseBrc80(bytes, 0), raw, bytes);
+        case SprmCodes.sprmPBrcTop80: return setMeta('para', 'borderTop', parseBrc80(bytes, 0), raw, bytes);
+        case SprmCodes.sprmPBrcTop: return setMeta('para', 'borderTop', parseBrc(bytes, 1), raw, bytes);
+        case SprmCodes.sprmPBrcLeft80: return setMeta('para', 'borderLeft', parseBrc80(bytes, 0), raw, bytes);
+        case SprmCodes.sprmPBrcLeft: return setMeta('para', 'borderLeft', parseBrc(bytes, 1), raw, bytes);
+        case SprmCodes.sprmPBrcBottom80: return setMeta('para', 'borderBottom', parseBrc80(bytes, 0), raw, bytes);
+        case SprmCodes.sprmPBrcBottom: return setMeta('para', 'borderBottom', parseBrc(bytes, 1), raw, bytes);
+        case SprmCodes.sprmPBrcRight80: return setMeta('para', 'borderRight', parseBrc80(bytes, 0), raw, bytes);
+        case SprmCodes.sprmPBrcRight: return setMeta('para', 'borderRight', parseBrc(bytes, 1), raw, bytes);
+        case SprmCodes.sprmPBrcBetween80: return setMeta('para', 'borderBetween', parseBrc80(bytes, 0), raw, bytes);
+        case SprmCodes.sprmPBrcBetween: return setMeta('para', 'borderBetween', parseBrc(bytes, 1), raw, bytes);
+        case SprmCodes.sprmPBrcBar80: return setMeta('para', 'borderBar', parseBrc80(bytes, 0), raw, bytes);
+        case SprmCodes.sprmPBrcBar: return setMeta('para', 'borderBar', parseBrc(bytes, 1), raw, bytes);
         case SprmCodes.sprmPWHeightAbs: return setMeta('para', 'frameHeight', i16(bytes, 0), raw, bytes);
         case SprmCodes.sprmPShd80:
         case SprmCodes.sprmPShd: return setMeta('para', 'shading', bytes.slice(), raw, bytes);
@@ -449,6 +583,15 @@ export function decodeSprm(sprm, operandBytes) {
         case SprmCodes.sprmTTableHeader: return setMeta('table', 'header', boolValue(bytes), raw, bytes);
         case SprmCodes.sprmTDyaRowHeight: return setMeta('table', 'rowHeight', i16(bytes, 0), raw, bytes);
         case SprmCodes.sprmTDefTable: return setMeta('table', 'defTable', parseTDefTableOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTTableBorders80: return setMeta('table', 'tableBorders', parseTableBorders(bytes, true), raw, bytes);
+        case SprmCodes.sprmTTableBorders: return setMeta('table', 'tableBorders', parseTableBorders(bytes, false), raw, bytes);
+        case SprmCodes.sprmTDefTableShd80: return setMeta('table', 'defaultShading', parseDefaultShading(bytes, 0, true), raw, bytes);
+        case SprmCodes.sprmTDefTableShd:
+        case SprmCodes.sprmTDefTableShdRaw: return setMeta('table', 'defaultShading', parseDefaultShading(bytes, 0, false), raw, bytes);
+        case SprmCodes.sprmTDefTableShd2nd:
+        case SprmCodes.sprmTDefTableShdRaw2nd: return setMeta('table', 'defaultShading', parseDefaultShading(bytes, 22, false), raw, bytes);
+        case SprmCodes.sprmTDefTableShd3rd:
+        case SprmCodes.sprmTDefTableShdRaw3rd: return setMeta('table', 'defaultShading', parseDefaultShading(bytes, 44, false), raw, bytes);
         case SprmCodes.sprmTFBiDi: return setMeta('table', 'rtl', boolValue(bytes), raw, bytes);
         case SprmCodes.sprmTPc: return setMeta('table', 'positionCode', bytes[0] ?? 0, raw, bytes);
         case SprmCodes.sprmTDxaAbs: return setMeta('table', 'absLeft', i16(bytes, 0), raw, bytes);
@@ -461,20 +604,24 @@ export function decodeSprm(sprm, operandBytes) {
         case SprmCodes.sprmTWidthAfter: return setMeta('table', 'widthAfter', parseTTableWidth(bytes), raw, bytes);
         case SprmCodes.sprmTInsert: return setMeta('table', 'insertCells', parseTInsertOperand(bytes), raw, bytes);
         case SprmCodes.sprmTDelete: return setMeta('table', 'deleteCells', parseItcFirstLim(bytes, 0), raw, bytes);
-        case SprmCodes.sprmTDxaCol: return setMeta('table', 'columnWidth', parseRangeWidthOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTDxaCol: return setMeta('table', 'columnWidth', parseFixedRangeWidthOperand(bytes), raw, bytes);
         case SprmCodes.sprmTMerge: return setMeta('table', 'merge', parseItcFirstLim(bytes, 0), raw, bytes);
         case SprmCodes.sprmTSplit: return setMeta('table', 'split', parseItcFirstLim(bytes, 0), raw, bytes);
-        case SprmCodes.sprmTTextFlow: return setMeta('table', 'textFlow', parseRangeValueOperand(bytes), raw, bytes);
-        case SprmCodes.sprmTVertMerge: return setMeta('table', 'vertMerge', parseRangeValueOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTTextFlow: return setMeta('table', 'textFlow', {
+            range: parseItcFirstLim(bytes, 0),
+            value: u16(bytes, 2),
+        }, raw, bytes);
+        case SprmCodes.sprmTVertMerge: return setMeta('table', 'vertMerge', parseVertMergeOperand(bytes), raw, bytes);
         case SprmCodes.sprmTVertAlign: return setMeta('table', 'vertAlign', parseRangeValueOperand(bytes), raw, bytes);
-        case SprmCodes.sprmTSetShd:
-        case SprmCodes.sprmTSetShdOdd: return setMeta('table', 'setShading', parseRangeValueOperand(bytes), raw, bytes);
-        case SprmCodes.sprmTSetBrc80:
-        case SprmCodes.sprmTSetBrc: return setMeta('table', 'setBorder', parseRangeBrcOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTSetShd: return setMeta('table', 'setShading', parseTableShadeOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTSetShdOdd: return setMeta('table', 'setShading', parseTableShadeOperand(bytes, true), raw, bytes);
+        case SprmCodes.sprmTSetBrc80: return setMeta('table', 'setBorder', parseRangeBrcOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTSetBrc: return setMeta('table', 'setBorder', parseRangeBrcOperand97(bytes), raw, bytes);
         case SprmCodes.sprmTCellPadding:
-        case SprmCodes.sprmTCellPaddingDefault: return setMeta('table', 'cellPadding', parseRangeWidthOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTCellPaddingDefault: return setMeta('table', 'cellPadding', parseCssaOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTCellSpacingDefault: return setMeta('table', 'cellSpacing', parseCssaOperand(bytes), raw, bytes);
         case SprmCodes.sprmTCellWidth: return setMeta('table', 'cellWidth', parseRangeWidthOperand(bytes), raw, bytes);
-        case SprmCodes.sprmTFitText: return setMeta('table', 'fitText', parseRangeValueOperand(bytes), raw, bytes);
+        case SprmCodes.sprmTFitText: return setMeta('table', 'fitText', parseFixedRangeValueOperand(bytes), raw, bytes);
         case SprmCodes.sprmTFCellNoWrap: return setMeta('table', 'cellNoWrap', parseRangeValueOperand(bytes), raw, bytes);
         case SprmCodes.sprmTIstd: return setMeta('table', 'styleId', u16(bytes, 0), raw, bytes);
         default: {

package/dist/msdoc/styles.js

@@ -1,11 +1,31 @@
 import { BinaryReader } from '../core/binary.js';
 import { alignEven } from '../core/utils.js';
 import { decodeGrpprl } from './sprm.js';
+const REPEATABLE_TABLE_PROPERTIES = new Set([
+    'insertCells',
+    'deleteCells',
+    'columnWidth',
+    'merge',
+    'split',
+    'textFlow',
+    'vertMerge',
+    'vertAlign',
+    'setShading',
+    'defaultShading',
+    'setBorder',
+    'cellPadding',
+    'cellSpacing',
+    'cellWidth',
+    'fitText',
+    'cellNoWrap',
+]);
 function mergePropertyArrays(...arrays) {
     const map = new Map();
+    let sequence = 0;
     for (const array of arrays) {
         for (const prop of array || []) {
-            map.set(`${prop.kind}:${prop.name}`, prop);
+            const repeatable = prop.kind === 'table' && REPEATABLE_TABLE_PROPERTIES.has(prop.name);
+            map.set(repeatable ? `${prop.kind}:${prop.name}:${sequence++}` : `${prop.kind}:${prop.name}`, prop);
         }
     }
     return Array.from(map.values());

package/dist/render/html.js

@@ -26,15 +26,72 @@ function styleObjectToCss(style) {
         .join(';');
 }
 function borderToCss(border) {
-    if (!border)
+    if (!border || border.nil)
         return null;
-    const width = Math.max(1, Math.round(((border.lineWidth ?? 8) / 8) * 1.3333));
     const borderType = border.borderType;
-    const style = borderType === 6 ? 'double' : borderType === 3 ? 'dotted' : borderType === 2 ? 'dashed' : 'solid';
+    if (!borderType)
+        return null;
+    const lineWidth = Math.max(2, border.lineWidth || 0);
+    const widthPoints = borderType >= 0x40 ? lineWidth : lineWidth / 8;
+    const width = Math.max(1, Math.round(widthPoints * (96 / 72)));
+    const style = borderType === 3
+        ? 'double'
+        : borderType === 6
+            ? 'dotted'
+            : [7, 8, 9].includes(borderType)
+                ? 'dashed'
+                : 'solid';
     const colorIndex = border.color;
-    const color = colorIndex ? COLOR_INDEX_MAP[colorIndex] || '#666' : '#666';
+    const color = border.colorRef != null
+        ? colorRefToCss(border.colorRef)
+        : COLOR_INDEX_MAP[colorIndex || 1] || '#000000';
     return `${width}px ${style} ${color}`;
 }
+function colorRefToCss(colorRef) {
+    if (colorRef == null || (colorRef >>> 24) === 0xff)
+        return '#000000';
+    const red = colorRef & 0xff;
+    const green = (colorRef >>> 8) & 0xff;
+    const blue = (colorRef >>> 16) & 0xff;
+    return `#${[red, green, blue].map(value => value.toString(16).padStart(2, '0')).join('')}`;
+}
+const SHADING_PERCENT = {
+    2: 5, 3: 10, 4: 20, 5: 25, 6: 30, 7: 40,
+    8: 50, 9: 60, 10: 70, 11: 75, 12: 80, 13: 90,
+};
+function mixHexColors(foreground, background, percent) {
+    const channel = (color, offset) => Number.parseInt(color.slice(offset, offset + 2), 16);
+    const ratio = Math.max(0, Math.min(100, percent)) / 100;
+    const values = [1, 3, 5].map(offset => Math.round(channel(foreground, offset) * ratio + channel(background, offset) * (1 - ratio)));
+    return `#${values.map(value => value.toString(16).padStart(2, '0')).join('')}`;
+}
+function shadingToCss(shading) {
+    if (!shading || shading.nil || shading.auto || shading.pattern === 0)
+        return {};
+    const foreground = shading.foregroundColorRef != null
+        ? colorRefToCss(shading.foregroundColorRef)
+        : COLOR_INDEX_MAP[shading.foregroundColorIndex || 1] || '#000000';
+    const background = shading.backgroundColorRef != null
+        ? colorRefToCss(shading.backgroundColorRef)
+        : COLOR_INDEX_MAP[shading.backgroundColorIndex || 8] || '#ffffff';
+    if (shading.pattern === 1)
+        return { 'background-color': foreground };
+    if (SHADING_PERCENT[shading.pattern] != null) {
+        return { 'background-color': mixHexColors(foreground, background, SHADING_PERCENT[shading.pattern]) };
+    }
+    const stripe = shading.pattern === 14 || shading.pattern === 20
+        ? `repeating-linear-gradient(0deg,${foreground} 0 1px,transparent 1px 4px)`
+        : shading.pattern === 15 || shading.pattern === 21
+            ? `repeating-linear-gradient(90deg,${foreground} 0 1px,transparent 1px 4px)`
+            : shading.pattern === 16 || shading.pattern === 22
+                ? `repeating-linear-gradient(45deg,${foreground} 0 1px,transparent 1px 5px)`
+                : shading.pattern === 17 || shading.pattern === 23
+                    ? `repeating-linear-gradient(-45deg,${foreground} 0 1px,transparent 1px 5px)`
+                    : null;
+    return stripe
+        ? { 'background-color': background, 'background-image': stripe }
+        : { 'background-color': background };
+}
 function paragraphStyleToCss(paraState) {
     const style = {
         'text-align': cssTextAlign(paraState.alignment),
@@ -74,11 +131,11 @@ function paragraphStyleToCss(paraState) {
     if (top)
         style['border-top'] = top;
     if (right)
-        style['border-right'] = right;
+        style['border-inline-end'] = right;
     if (bottom)
         style['border-bottom'] = bottom;
     if (left)
-        style['border-left'] = left;
+        style['border-inline-start'] = left;
     return style;
 }
 function buildUnderlineStyle(underline) {
@@ -263,25 +320,33 @@ function cellStyle(cell) {
         style['text-align'] = 'justify';
     if (cell.meta?.vertAlign != null)
         style['vertical-align'] = cssVerticalAlign(cell.meta.vertAlign);
-    const borderAll = borderToCss(cell.meta?.borders?.all);
-    const top = borderToCss(cell.meta?.borders?.top) || borderAll;
-    const right = borderToCss(cell.meta?.borders?.right) || borderAll;
-    const bottom = borderToCss(cell.meta?.borders?.bottom) || borderAll;
-    const left = borderToCss(cell.meta?.borders?.left) || borderAll;
+    const borders = cell.meta?.borders || {};
+    const borderAll = borderToCss(borders.all);
+    const borderForSide = (side) => Object.prototype.hasOwnProperty.call(borders, side)
+        ? borderToCss(borders[side])
+        : borderAll;
+    const top = borderForSide('top');
+    const right = borderForSide('right');
+    const bottom = borderForSide('bottom');
+    const left = borderForSide('left');
     if (top)
         style['border-top'] = top;
     if (right)
-        style['border-right'] = right;
+        style['border-inline-end'] = right;
     if (bottom)
         style['border-bottom'] = bottom;
     if (left)
-        style['border-left'] = left;
-    const shadingColor = typeof cell.meta?.shading === 'object' && cell.meta?.shading && 'color' in cell.meta.shading
-        ? cell.meta.shading.color
-        : undefined;
-    if (shadingColor && COLOR_INDEX_MAP[shadingColor]) {
-        style['background-color'] = COLOR_INDEX_MAP[shadingColor];
-    }
+        style['border-inline-start'] = left;
+    const padding = cell.meta?.paddingTwips;
+    if (padding?.top != null)
+        style['padding-top'] = `${twipsToPx(padding.top)}px`;
+    if (padding?.right != null)
+        style['padding-inline-end'] = `${twipsToPx(padding.right)}px`;
+    if (padding?.bottom != null)
+        style['padding-bottom'] = `${twipsToPx(padding.bottom)}px`;
+    if (padding?.left != null)
+        style['padding-inline-start'] = `${twipsToPx(padding.left)}px`;
+    Object.assign(style, shadingToCss(cell.meta?.shading));
     return style;
 }
 function tableStyle(block) {
@@ -293,8 +358,25 @@ function tableStyle(block) {
         style.width = '100%';
     const marginLeft = twipsToPx(block.state?.leftIndent);
     if (marginLeft)
-        style['margin-left'] = `${marginLeft}px`;
-    style['border-collapse'] = 'collapse';
+        style['margin-inline-start'] = `${marginLeft}px`;
+    if (block.state?.rtl)
+        style.direction = 'rtl';
+    const spacing = block.rows.flatMap(row => row.cells).reduce((maximum, cell) => {
+        const value = cell.meta?.spacingTwips;
+        if (!value)
+            return maximum;
+        return {
+            horizontal: Math.max(maximum.horizontal, value.left || 0, value.right || 0),
+            vertical: Math.max(maximum.vertical, value.top || 0, value.bottom || 0),
+        };
+    }, { horizontal: 0, vertical: 0 });
+    if (spacing.horizontal || spacing.vertical) {
+        style['border-collapse'] = 'separate';
+        style['border-spacing'] = `${twipsToPx(spacing.horizontal)}px ${twipsToPx(spacing.vertical)}px`;
+    }
+    else {
+        style['border-collapse'] = 'collapse';
+    }
     style['table-layout'] = 'fixed';
     return style;
 }

package/dist/types.d.ts

@@ -211,8 +211,31 @@ export interface BorderSpec {
     borderType?: number;
     lineWidth?: number;
     color?: number;
+    colorRef?: number;
+    frame?: boolean;
+    nil?: boolean;
+    shadow?: boolean;
+    space?: number;
     [key: string]: unknown;
 }
+export interface TableBorders {
+    top?: BorderSpec;
+    left?: BorderSpec;
+    bottom?: BorderSpec;
+    right?: BorderSpec;
+    horizontalInside?: BorderSpec;
+    verticalInside?: BorderSpec;
+}
+export interface ShadingSpec {
+    foregroundColorIndex?: number;
+    backgroundColorIndex?: number;
+    foregroundColorRef?: number;
+    backgroundColorRef?: number;
+    pattern: number;
+    auto?: boolean;
+    nil?: boolean;
+    legacy?: boolean;
+}
 export interface HighlightInfo {
     index: number;
     color?: string;
@@ -326,6 +349,7 @@ export interface ItcRange {
 export interface RangeWidthOperand {
     cb?: number;
     range: ItcRange;
+    sides?: number;
     width?: number;
     wWidth?: number;
     ftsWidth?: number;
@@ -334,6 +358,7 @@ export interface RangeBorderOperand {
     cb?: number;
     range: ItcRange;
     border: BorderSpec;
+    bordersToApply: number;
     extra?: Uint8Array;
 }
 export interface RangeValueOperand {
@@ -348,13 +373,9 @@ export interface TableWidthOperand {
     wWidth?: number;
 }
 export interface TInsertOperand {
-    cb?: number;
-    range?: ItcRange;
     itcFirst?: number;
-    dxaCol?: number[] | number;
-    dxaGapHalf?: number;
     ctc?: number;
-    cells?: unknown[];
+    dxaCol?: number;
     [key: string]: unknown;
 }
 export interface TableState {
@@ -375,6 +396,7 @@ export interface TableState {
     autoFit?: unknown;
     widthBefore?: unknown;
     widthAfter?: unknown;
+    borders: TableBorders;
     defTable?: TDefTableOperand;
     operations: DecodedProperty[];
     [key: string]: unknown;
@@ -393,7 +415,9 @@ export interface TableCellMeta {
     textFlow?: number;
     rightBoundary?: number;
     leftBoundary?: number;
-    shading?: unknown;
+    shading?: ShadingSpec;
+    paddingTwips?: Partial<Record<'top' | 'left' | 'bottom' | 'right', number>>;
+    spacingTwips?: Partial<Record<'top' | 'left' | 'bottom' | 'right', number>>;
 }
 export interface CharSegment {
     cpStart: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/doc",
-  "version": "2.1.26",
+  "version": "2.1.28",
   "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.",
@@ -68,6 +68,7 @@
   "scripts": {
     "build": "tsc -b tsconfig.json",
     "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"
   }