@a3s-lab/office 0.1.0 → 0.2.2

package/dist/0~work-docx-import.js

@@ -1,9 +1,9 @@
 import jszip from "jszip";
 import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, childPath, attribute } from "./8715.js";
 import { docxCaptionSequenceKind, docxFieldOccurrences, docxCaptionBookmark, docxFieldResultText, docxCaptionReferenceTarget } from "./0~152.js";
-import { documentContentLayoutProperties, documentPageChromeLegacyFields, normalizeDocumentFieldsHtml, documentInitialSectionLayout, documentSectionDomAttributes, documentCaptionLabel, normalizeDocumentPageChrome, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentCaptionsHtml, normalizeDocumentNotesHtml, documentCitationTagsFromInstruction, docxDocumentFieldKind, createDocumentNoteElement } from "./4704.js";
-import { normalizeDocumentImageAlignment, serializeDocumentTabStops, normalizeDocumentImageLayoutOptions, normalizeDocumentTabStops } from "./0~8155.js";
-import { normalizeDocumentParagraphIndent } from "./0~work-document-paragraph-formatting.js";
+import { documentContentLayoutProperties, documentPageChromeLegacyFields, normalizeDocumentFieldsHtml, documentInitialSectionLayout, documentSectionDomAttributes, documentCaptionLabel, normalizeDocumentPageChrome, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentCaptionsHtml, normalizeDocumentNotesHtml, documentCitationTagsFromInstruction, docxDocumentFieldKind, createDocumentNoteElement } from "./2881.js";
+import { renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, normalizeDocumentImageAlignment, documentTableBordersFromElement, normalizeDocumentImageLayoutOptions, normalizeDocumentTabStops, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, serializeDocumentTabStops, applyDocumentTableGeometryToElement } from "./0~4750.js";
+import { normalizeDocumentParagraphIndent, documentAutoLineHeight, documentWordLineHeightFactor, renderDocumentAutoLineHeight } from "./0~5861.js";
 import { readDocxBibliography } from "./0~work-docx-bibliography.js";
 import { importDocxPageColor } from "./0~work-docx-page-color.js";
 const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
@@ -1332,21 +1332,23 @@ function createDocxParagraphStyleResolver(stylesDocument) {
 function resolveDocxParagraphStyleResolver(source) {
     return source && 'styles' in source ? source : createDocxParagraphStyleResolver(source);
 }
-function docxParagraphPropertySources(directProperties, resolver) {
+function docxParagraphPropertySources(directProperties, resolver, contextualProperties = []) {
     const sources = [];
     if (resolver.defaultProperties) sources.push(resolver.defaultProperties);
     const styleReference = directProperties ? directChild(directProperties, 'pStyle') : void 0;
     const styleId = (styleReference ? wordAttribute(styleReference, 'val')?.trim() : void 0) || resolver.defaultStyleId;
     if (styleId) sources.push(...stylePropertySources(resolver.styles, styleId, 'paragraphProperties'));
+    sources.push(...contextualProperties);
     if (directProperties) sources.push(directProperties);
     return sources;
 }
-function docxRunPropertySources(paragraphProperties, runProperties, resolver) {
+function docxRunPropertySources(paragraphProperties, runProperties, resolver, contextualProperties = []) {
     const sources = [];
     if (resolver.defaultRunProperties) sources.push(resolver.defaultRunProperties);
     const paragraphStyleReference = paragraphProperties ? directChild(paragraphProperties, 'pStyle') : void 0;
     const paragraphStyleId = (paragraphStyleReference ? wordAttribute(paragraphStyleReference, 'val')?.trim() : void 0) || resolver.defaultStyleId;
     if (paragraphStyleId) sources.push(...stylePropertySources(resolver.styles, paragraphStyleId, 'runProperties'));
+    sources.push(...contextualProperties);
     const paragraphRunProperties = paragraphProperties ? directChild(paragraphProperties, 'rPr') : void 0;
     if (paragraphRunProperties) sources.push(paragraphRunProperties);
     const characterStyleReference = runProperties ? directChild(runProperties, 'rStyle') : void 0;
@@ -1379,15 +1381,266 @@ function onOffAttribute(element, name) {
 function wordAttribute(element, name) {
     return attribute(element, name) ?? attribute(element, `w:${name}`);
 }
+const work_docx_table_styles_MAX_STYLE_INHERITANCE_DEPTH = 64;
+const DEFAULT_TABLE_LOOK = {
+    firstRow: true,
+    lastRow: false,
+    firstColumn: true,
+    lastColumn: false,
+    noHorizontalBand: false,
+    noVerticalBand: true
+};
+const TABLE_LOOK_BITS = {
+    firstRow: 0x0020,
+    lastRow: 0x0040,
+    firstColumn: 0x0080,
+    lastColumn: 0x0100,
+    noHorizontalBand: 0x0200,
+    noVerticalBand: 0x0400
+};
+function createDocxTableStyleResolver(stylesDocument) {
+    if (!stylesDocument) return {
+        tableStyles: new Map()
+    };
+    const tableStyles = new Map();
+    let defaultStyleId;
+    for (const style of descendants(stylesDocument, 'style')){
+        if ('table' !== work_docx_table_styles_wordAttribute(style, 'type')) continue;
+        const styleId = work_docx_table_styles_wordAttribute(style, 'styleId')?.trim();
+        if (!styleId) continue;
+        const basedOn = directChild(style, 'basedOn');
+        const conditional = new Map();
+        for (const conditionalStyle of directChildren(style, 'tblStylePr')){
+            const type = work_docx_table_styles_wordAttribute(conditionalStyle, 'type')?.trim();
+            if (type) conditional.set(type, styleLayer(conditionalStyle));
+        }
+        tableStyles.set(styleId, {
+            ...styleLayer(style),
+            basedOn: basedOn ? work_docx_table_styles_wordAttribute(basedOn, 'val')?.trim() || void 0 : void 0,
+            conditional
+        });
+        if (!defaultStyleId && work_docx_table_styles_onOffAttribute(style, 'default')) defaultStyleId = styleId;
+    }
+    return {
+        defaultStyleId,
+        tableStyles
+    };
+}
+function resolveDocxTableStyleResolver(source) {
+    return source && 'tableStyles' in source ? source : createDocxTableStyleResolver(source);
+}
+function docxTablePropertySources(table, resolver) {
+    const directTableProperties = directChild(table, 'tblPr');
+    const styleReference = directTableProperties ? directChild(directTableProperties, 'tblStyle') : void 0;
+    const styleId = (styleReference ? work_docx_table_styles_wordAttribute(styleReference, 'val')?.trim() : void 0) || resolver.defaultStyleId;
+    const sources = styleId ? tableStyleChain(resolver.tableStyles, styleId).map(({ tableProperties })=>tableProperties).filter((properties)=>Boolean(properties)) : [];
+    if (directTableProperties) sources.push(directTableProperties);
+    return sources;
+}
+function docxTableCellStyleLayers(cell, resolver) {
+    const table = work_docx_table_styles_closestAncestor(cell, 'tbl');
+    if (!table) return [];
+    const directTableProperties = directChild(table, 'tblPr');
+    const styleReference = directTableProperties ? directChild(directTableProperties, 'tblStyle') : void 0;
+    const styleId = (styleReference ? work_docx_table_styles_wordAttribute(styleReference, 'val')?.trim() : void 0) || resolver.defaultStyleId;
+    if (!styleId) return [];
+    const styles = tableStyleChain(resolver.tableStyles, styleId);
+    if (!styles.length) return [];
+    const unconditionalLayers = styles.map(styleLayerFromStyle);
+    const propertySources = unconditionalLayers.map(({ tableProperties })=>tableProperties).filter((properties)=>Boolean(properties));
+    if (directTableProperties) propertySources.push(directTableProperties);
+    const position = tableCellPosition(table, cell);
+    if (!position) return unconditionalLayers;
+    const look = resolveTableLook(propertySources);
+    const rowBandSize = resolveBandSize(propertySources, 'tblStyleRowBandSize');
+    const columnBandSize = resolveBandSize(propertySources, 'tblStyleColBandSize');
+    const layers = [
+        ...unconditionalLayers
+    ];
+    for (const condition of applicableConditions(position, look, rowBandSize, columnBandSize))for (const style of styles){
+        const layer = style.conditional.get(condition);
+        if (layer) layers.push(layer);
+    }
+    return layers;
+}
+function docxTableRunPropertySources(element, resolver) {
+    const cell = work_docx_table_styles_closestAncestor(element, 'tc');
+    if (!cell) return [];
+    const sources = [];
+    for (const layer of docxTableCellStyleLayers(cell, resolver)){
+        const paragraphRunProperties = layer.paragraphProperties ? directChild(layer.paragraphProperties, 'rPr') : void 0;
+        if (paragraphRunProperties) sources.push(paragraphRunProperties);
+        if (layer.runProperties) sources.push(layer.runProperties);
+    }
+    return sources;
+}
+function docxTableParagraphPropertySources(element, resolver) {
+    const cell = work_docx_table_styles_closestAncestor(element, 'tc');
+    if (!cell) return [];
+    return docxTableCellStyleLayers(cell, resolver).map(({ paragraphProperties })=>paragraphProperties).filter((properties)=>Boolean(properties));
+}
+function styleLayer(parent) {
+    return {
+        tableProperties: directChild(parent, 'tblPr'),
+        cellProperties: directChild(parent, 'tcPr'),
+        paragraphProperties: directChild(parent, 'pPr'),
+        runProperties: directChild(parent, 'rPr')
+    };
+}
+function styleLayerFromStyle(style) {
+    return {
+        tableProperties: style.tableProperties,
+        cellProperties: style.cellProperties,
+        paragraphProperties: style.paragraphProperties,
+        runProperties: style.runProperties
+    };
+}
+function tableStyleChain(styles, styleId) {
+    const inherited = [];
+    const visited = new Set();
+    let currentStyleId = styleId;
+    let depth = 0;
+    while(currentStyleId && depth < work_docx_table_styles_MAX_STYLE_INHERITANCE_DEPTH && !visited.has(currentStyleId)){
+        depth += 1;
+        visited.add(currentStyleId);
+        const style = styles.get(currentStyleId);
+        if (!style) break;
+        inherited.push(style);
+        currentStyleId = style.basedOn;
+    }
+    return inherited.reverse();
+}
+function applicableConditions(position, look, rowBandSize, columnBandSize) {
+    const conditions = [
+        'wholeTable'
+    ];
+    const isFirstRow = 0 === position.rowIndex;
+    const isLastRow = position.rowIndex === position.rowCount - 1;
+    const isFirstColumn = 0 === position.columnStart;
+    const isLastColumn = position.columnEnd === position.columnCount - 1;
+    if (!look.noVerticalBand) {
+        const offset = look.firstColumn ? 1 : 0;
+        const bandIndex = position.columnStart - offset;
+        if (bandIndex >= 0) conditions.push(Math.floor(bandIndex / columnBandSize) % 2 === 0 ? 'band1Vert' : 'band2Vert');
+    }
+    if (!look.noHorizontalBand) {
+        const offset = look.firstRow ? 1 : 0;
+        const bandIndex = position.rowIndex - offset;
+        if (bandIndex >= 0) conditions.push(Math.floor(bandIndex / rowBandSize) % 2 === 0 ? 'band1Horz' : 'band2Horz');
+    }
+    if (look.firstColumn && isFirstColumn) conditions.push('firstCol');
+    if (look.lastColumn && isLastColumn) conditions.push('lastCol');
+    if (look.firstRow && isFirstRow) conditions.push('firstRow');
+    if (look.lastRow && isLastRow) conditions.push('lastRow');
+    if (look.firstRow && isFirstRow && look.firstColumn && isFirstColumn) conditions.push('nwCell');
+    if (look.firstRow && isFirstRow && look.lastColumn && isLastColumn) conditions.push('neCell');
+    if (look.lastRow && isLastRow && look.firstColumn && isFirstColumn) conditions.push('swCell');
+    if (look.lastRow && isLastRow && look.lastColumn && isLastColumn) conditions.push('seCell');
+    return conditions;
+}
+function resolveTableLook(propertySources) {
+    const look = {
+        ...DEFAULT_TABLE_LOOK
+    };
+    for (const properties of propertySources){
+        const element = directChild(properties, 'tblLook');
+        if (!element) continue;
+        const encoded = work_docx_table_styles_wordAttribute(element, 'val')?.trim();
+        if (encoded && /^[0-9a-f]{1,4}$/i.test(encoded)) {
+            const value = Number.parseInt(encoded, 16);
+            look.firstRow = Boolean(value & TABLE_LOOK_BITS.firstRow);
+            look.lastRow = Boolean(value & TABLE_LOOK_BITS.lastRow);
+            look.firstColumn = Boolean(value & TABLE_LOOK_BITS.firstColumn);
+            look.lastColumn = Boolean(value & TABLE_LOOK_BITS.lastColumn);
+            look.noHorizontalBand = Boolean(value & TABLE_LOOK_BITS.noHorizontalBand);
+            look.noVerticalBand = Boolean(value & TABLE_LOOK_BITS.noVerticalBand);
+        }
+        assignLookFlag(look, 'firstRow', element, 'firstRow');
+        assignLookFlag(look, 'lastRow', element, 'lastRow');
+        assignLookFlag(look, 'firstColumn', element, 'firstColumn');
+        assignLookFlag(look, 'lastColumn', element, 'lastColumn');
+        assignLookFlag(look, 'noHorizontalBand', element, 'noHBand');
+        assignLookFlag(look, 'noVerticalBand', element, 'noVBand');
+    }
+    return look;
+}
+function assignLookFlag(look, key, element, attributeName) {
+    const value = onOffValue(work_docx_table_styles_wordAttribute(element, attributeName));
+    if (void 0 !== value) look[key] = value;
+}
+function resolveBandSize(propertySources, propertyName) {
+    let size = 1;
+    for (const properties of propertySources){
+        const element = directChild(properties, propertyName);
+        const value = Number(element ? work_docx_table_styles_wordAttribute(element, 'val') : void 0);
+        if (Number.isInteger(value) && value > 0 && value <= 64) size = value;
+    }
+    return size;
+}
+function tableCellPosition(table, targetCell) {
+    const rows = descendants(table, 'tr').filter((row)=>work_docx_table_styles_closestAncestor(row, 'tbl') === table);
+    const targetRow = work_docx_table_styles_closestAncestor(targetCell, 'tr');
+    if (!targetRow) return null;
+    const rowIndex = rows.indexOf(targetRow);
+    if (rowIndex < 0) return null;
+    const cells = rowCells(targetRow);
+    const cellIndex = cells.indexOf(targetCell);
+    if (cellIndex < 0) return null;
+    const columnStart = rowGridOffset(targetRow, 'gridBefore') + cells.slice(0, cellIndex).reduce((total, cell)=>total + cellGridSpan(cell), 0);
+    const columnEnd = columnStart + cellGridSpan(targetCell) - 1;
+    const columnCount = Math.max(1, ...rows.map((row)=>rowGridOffset(row, 'gridBefore') + rowCells(row).reduce((total, cell)=>total + cellGridSpan(cell), 0) + rowGridOffset(row, 'gridAfter')));
+    return {
+        rowIndex,
+        rowCount: rows.length,
+        columnStart,
+        columnEnd,
+        columnCount
+    };
+}
+function rowCells(row) {
+    return descendants(row, 'tc').filter((cell)=>work_docx_table_styles_closestAncestor(cell, 'tr') === row);
+}
+function cellGridSpan(cell) {
+    const properties = directChild(cell, 'tcPr');
+    const gridSpan = properties ? directChild(properties, 'gridSpan') : void 0;
+    const value = Number(gridSpan ? work_docx_table_styles_wordAttribute(gridSpan, 'val') : void 0);
+    return Number.isInteger(value) && value > 0 && value <= 256 ? value : 1;
+}
+function rowGridOffset(row, propertyName) {
+    const properties = directChild(row, 'trPr');
+    const element = properties ? directChild(properties, propertyName) : void 0;
+    const value = Number(element ? work_docx_table_styles_wordAttribute(element, 'val') : void 0);
+    return Number.isInteger(value) && value > 0 && value <= 256 ? value : 0;
+}
+function work_docx_table_styles_closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function work_docx_table_styles_onOffAttribute(element, name) {
+    return onOffValue(work_docx_table_styles_wordAttribute(element, name)) ?? false;
+}
+function onOffValue(value) {
+    if (null == value) return;
+    const normalized = value.trim().toLowerCase();
+    return '0' !== normalized && 'false' !== normalized && 'off' !== normalized;
+}
+function work_docx_table_styles_wordAttribute(element, name) {
+    return attribute(element, name) ?? attribute(element, `w:${name}`);
+}
 const work_docx_paragraph_direction_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_paragraph_direction_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const PARAGRAPH_DIRECTION_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_DIRECTION_\d+__/g;
-function markDocxParagraphDirections(document, styleSource) {
+function markDocxParagraphDirections(document, styleSource, tableStyleSource) {
     const paragraphs = [];
     const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const paragraph of descendants(document, 'p')){
         let properties = directChild(paragraph, 'pPr');
-        const sources = docxParagraphPropertySources(properties, styles);
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
         const direction = paragraphDirection(sources);
         if (!direction) continue;
         properties ??= insertParagraphProperties(document, paragraph);
@@ -1425,11 +1678,11 @@ function paragraphDirection(propertySources) {
     let direction = null;
     for (const properties of propertySources){
         const bidi = directChild(properties, 'bidi');
-        if (bidi) direction = onOffValue(bidi) ? 'rtl' : 'ltr';
+        if (bidi) direction = work_docx_paragraph_direction_import_onOffValue(bidi) ? 'rtl' : 'ltr';
     }
     return direction;
 }
-function onOffValue(element) {
+function work_docx_paragraph_direction_import_onOffValue(element) {
     const value = (attribute(element, 'val') ?? attribute(element, 'w:val'))?.trim().toLowerCase();
     return '0' !== value && 'false' !== value && 'off' !== value;
 }
@@ -1461,12 +1714,13 @@ function work_docx_paragraph_direction_import_textNodes(root) {
 const work_docx_paragraph_alignment_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_paragraph_alignment_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const PARAGRAPH_ALIGNMENT_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_ALIGNMENT_\d+__/g;
-function markDocxParagraphAlignments(document, styleSource) {
+function markDocxParagraphAlignments(document, styleSource, tableStyleSource) {
     const paragraphs = [];
     const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const paragraph of descendants(document, 'p')){
         let properties = directChild(paragraph, 'pPr');
-        const sources = docxParagraphPropertySources(properties, styles);
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
         const alignment = paragraphAlignment(sources);
         if (!alignment) continue;
         properties ??= work_docx_paragraph_alignment_import_insertParagraphProperties(document, paragraph);
@@ -1591,12 +1845,13 @@ const work_docx_paragraph_indent_import_WORD_NAMESPACE = 'http://schemas.openxml
 const work_docx_paragraph_indent_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const TWIPS_PER_CSS_PIXEL = 15;
 const PARAGRAPH_INDENT_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_INDENT_\d+__/g;
-function markDocxParagraphIndents(document, styleSource) {
+function markDocxParagraphIndents(document, styleSource, tableStyleSource) {
     const paragraphs = [];
     const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const paragraph of descendants(document, 'p')){
         let properties = directChild(paragraph, 'pPr');
-        const sources = docxParagraphPropertySources(properties, styles);
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
         if (sources.some((source)=>directChild(source, 'numPr'))) continue;
         const indent = paragraphIndent(sources);
         if (!indent.left && !indent.right && !indent.firstLine) continue;
@@ -1709,13 +1964,14 @@ function work_docx_paragraph_indent_import_textNodes(root) {
 const work_docx_paragraph_pagination_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_paragraph_pagination_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const PARAGRAPH_PAGINATION_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_PAGINATION_\d+__/g;
-function markDocxParagraphPagination(document, styleSource) {
+function markDocxParagraphPagination(document, styleSource, tableStyleSource) {
     const paragraphs = [];
     const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const paragraph of descendants(document, 'p')){
         let properties = directChild(paragraph, 'pPr');
         if (properties && directChild(properties, 'numPr')) continue;
-        const pagination = paragraphPagination(docxParagraphPropertySources(properties, styles));
+        const pagination = paragraphPagination(docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles)));
         if (!Object.keys(pagination).length) continue;
         properties ??= work_docx_paragraph_pagination_import_insertParagraphProperties(document, paragraph);
         const marker = `__A3S_WORK_PARAGRAPH_PAGINATION_${paragraphs.length + 1}__`;
@@ -1803,12 +2059,13 @@ function work_docx_paragraph_pagination_import_textNodes(root) {
 const work_docx_paragraph_spacing_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_paragraph_spacing_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const PARAGRAPH_SPACING_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_SPACING_\d+__/g;
-function markDocxParagraphSpacing(document, styleSource) {
+function markDocxParagraphSpacing(document, styleSource, tableStyleSource) {
     const paragraphs = [];
     const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const paragraph of descendants(document, 'p')){
         let properties = directChild(paragraph, 'pPr');
-        const sources = docxParagraphPropertySources(properties, styles);
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
         if (sources.some((source)=>directChild(source, 'numPr'))) continue;
         const spacing = paragraphSpacing(sources);
         if (!Object.keys(spacing).length) continue;
@@ -1885,6 +2142,14 @@ function applyParagraphSpacing(element, spacing) {
     }
     if (spacing.lineHeight) element.style.lineHeight = spacing.lineHeight;
     if (spacing.lineRule) element.dataset.officeLineRule = spacing.lineRule;
+    if ('auto' === spacing.lineRule) {
+        const autoLineHeight = documentAutoLineHeight(spacing.lineHeight);
+        for (const [name, value] of Object.entries(renderDocumentAutoLineHeight(spacing.lineHeight, autoLineHeight)))if ('style' === name) for (const declaration of value.split(';')){
+            const separator = declaration.indexOf(':');
+            if (!(separator < 0)) element.style.setProperty(declaration.slice(0, separator).trim(), declaration.slice(separator + 1).trim());
+        }
+        else element.setAttribute(name, value);
+    }
 }
 function work_docx_paragraph_spacing_import_insertParagraphMarker(document, paragraph, properties, marker) {
     const run = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:r');
@@ -2020,10 +2285,11 @@ function isDocxThemeResolver(source) {
 const work_docx_run_formatting_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_run_formatting_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const RUN_FORMATTING_MARKER_PATTERN = /__A3S_WORK_RUN_(?:START|END)_\d+__/g;
-function markDocxRunFormatting(document, styleSource, themeSource) {
+function markDocxRunFormatting(document, styleSource, themeSource, tableStyleSource) {
     const runs = [];
     const styles = resolveDocxParagraphStyleResolver(styleSource);
     const theme = resolveDocxThemeResolver(themeSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const run of descendants(document, 'r')){
         const runText = directRunText(run);
         if (!runText || runText.includes('__A3S_')) continue;
@@ -2031,7 +2297,7 @@ function markDocxRunFormatting(document, styleSource, themeSource) {
         if (!paragraph) continue;
         const paragraphProperties = directChild(paragraph, 'pPr');
         const runProperties = directChild(run, 'rPr');
-        const formatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, runProperties, styles), theme);
+        const formatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, runProperties, styles, docxTableRunPropertySources(run, tableStyles)), theme, runText);
         if (!Object.keys(formatting).length) continue;
         const index = runs.length + 1;
         const startMarker = `__A3S_WORK_RUN_START_${index}__`;
@@ -2050,22 +2316,45 @@ function markDocxRunFormatting(document, styleSource, themeSource) {
 function applyImportedDocxRunFormattingMarkers(document, markers) {
     const replacements = new Map();
     for (const marker of markers.runs){
-        replacements.set(marker.startMarker, formattingSpanStart(document, marker.formatting));
-        replacements.set(marker.endMarker, '</span>');
+        const markup = formattingMarkup(document, marker.formatting);
+        replacements.set(marker.startMarker, markup.start);
+        replacements.set(marker.endMarker, markup.end);
     }
     document.body.innerHTML = document.body.innerHTML.replace(RUN_FORMATTING_MARKER_PATTERN, (marker)=>replacements.get(marker) ?? '');
 }
 function hasImportedDocxRunFormattingMarkers(markers) {
     return markers.runs.length > 0;
 }
-function resolvedRunFormatting(propertySources, theme) {
+function resolvedRunFormatting(propertySources, theme, runText) {
     const fonts = {};
     let fontSize;
+    let complexFontSize;
     let color;
     let backgroundColor;
+    let bold;
+    let complexBold;
+    let italic;
+    let complexItalic;
+    let underline;
+    let strike;
+    let snapToGrid;
+    let complexScriptFormatting;
+    let rightToLeft;
+    let fontHint;
     for (const properties of propertySources){
+        bold = overriddenBoolean(bold, onOffProperty(properties, 'b'));
+        complexBold = overriddenBoolean(complexBold, onOffProperty(properties, 'bCs'));
+        italic = overriddenBoolean(italic, onOffProperty(properties, 'i'));
+        complexItalic = overriddenBoolean(complexItalic, onOffProperty(properties, 'iCs'));
+        underline = overriddenBoolean(underline, underlineProperty(properties));
+        strike = overriddenBoolean(strike, onOffProperty(properties, 'strike'));
+        strike = overriddenBoolean(strike, onOffProperty(properties, 'dstrike'));
+        snapToGrid = overriddenBoolean(snapToGrid, onOffProperty(properties, 'snapToGrid'));
+        complexScriptFormatting = overriddenBoolean(complexScriptFormatting, onOffProperty(properties, 'cs'));
+        rightToLeft = overriddenBoolean(rightToLeft, onOffProperty(properties, 'rtl'));
         const runFonts = directChild(properties, 'rFonts');
         if (runFonts) {
+            fontHint = resolvedFontHint(runFonts) ?? fontHint;
             assignFont(fonts, 'ascii', resolvedFont(runFonts, 'ascii', 'asciiTheme', theme));
             assignFont(fonts, 'hAnsi', resolvedFont(runFonts, 'hAnsi', 'hAnsiTheme', theme));
             assignFont(fonts, 'eastAsia', resolvedFont(runFonts, 'eastAsia', 'eastAsiaTheme', theme));
@@ -2073,6 +2362,8 @@ function resolvedRunFormatting(propertySources, theme) {
         }
         const size = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'sz'), 'val');
         if (void 0 !== size && size > 0) fontSize = Math.min(512, size / 2);
+        const complexSize = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'szCs'), 'val');
+        if (void 0 !== complexSize && complexSize > 0) complexFontSize = Math.min(512, complexSize / 2);
         const colorElement = directChild(properties, 'color');
         if (colorElement) {
             const value = work_docx_run_formatting_import_wordAttribute(colorElement, 'val')?.trim();
@@ -2094,18 +2385,41 @@ function resolvedRunFormatting(propertySources, theme) {
             else if (fill && /^[0-9a-f]{6}$/i.test(fill)) backgroundColor = `#${fill.toLowerCase()}`;
         }
     }
-    const fontFamily = uniqueFonts([
-        fonts.eastAsia,
-        fonts.hAnsi,
-        fonts.ascii,
-        fonts.complex
-    ]);
+    const fontSlot = true === complexScriptFormatting || true === rightToLeft ? 'complex' : docxFontSlotForText(runText, fontHint);
+    const usesComplexFormatting = 'complex' === fontSlot;
+    const resolvedBold = usesComplexFormatting ? complexBold ?? bold : bold;
+    const resolvedItalic = usesComplexFormatting ? complexItalic ?? italic : italic;
+    const resolvedFontSize = usesComplexFormatting ? complexFontSize ?? fontSize : fontSize;
+    let fontFamily = uniqueFonts(orderedFonts(fonts, fontSlot));
+    if (!fontFamily) fontFamily = uniqueFonts(orderedFonts({
+        ascii: docxThemeFont(theme, 'minorAscii'),
+        hAnsi: docxThemeFont(theme, 'minorHAnsi'),
+        eastAsia: docxThemeFont(theme, 'minorEastAsia'),
+        complex: docxThemeFont(theme, 'minorBidi')
+    }, fontSlot));
+    const hasRunPropertySource = propertySources.length > 0;
     return {
+        ...void 0 !== resolvedBold || hasRunPropertySource ? {
+            bold: resolvedBold ?? false
+        } : {},
+        ...void 0 !== resolvedItalic || hasRunPropertySource ? {
+            italic: resolvedItalic ?? false
+        } : {},
+        ...void 0 !== underline || hasRunPropertySource ? {
+            underline: underline ?? false
+        } : {},
+        ...void 0 !== strike || hasRunPropertySource ? {
+            strike: strike ?? false
+        } : {},
         ...fontFamily ? {
-            fontFamily
+            fontFamily,
+            wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
         } : {},
-        ...void 0 !== fontSize ? {
-            fontSize
+        ...void 0 !== resolvedFontSize ? {
+            fontSize: resolvedFontSize
+        } : {},
+        ...void 0 !== snapToGrid ? {
+            wordSnapToGrid: snapToGrid
         } : {},
         ...color ? {
             color
@@ -2127,14 +2441,57 @@ function work_docx_run_formatting_import_markerText(document, marker) {
     text.textContent = marker;
     return text;
 }
-function formattingSpanStart(document, formatting) {
+function formattingMarkup(document, formatting) {
     const span = document.createElement('span');
+    if (false === formatting.bold) span.style.fontWeight = 'normal';
+    if (false === formatting.italic) span.style.fontStyle = 'normal';
+    if ((false === formatting.underline || false === formatting.strike) && !formatting.underline && !formatting.strike) span.style.textDecorationLine = 'none';
     if (formatting.fontFamily) span.style.fontFamily = formatting.fontFamily;
+    if (void 0 !== formatting.wordLineHeightFactor) {
+        const factor = formatLineHeightFactor(formatting.wordLineHeightFactor);
+        span.dataset.officeWordLineHeightFactor = factor;
+        span.style.setProperty('--work-document-word-line-height-factor', factor);
+    }
+    if (void 0 !== formatting.wordSnapToGrid) span.dataset.officeWordSnapToGrid = String(formatting.wordSnapToGrid);
     if (void 0 !== formatting.fontSize) span.style.fontSize = `${work_docx_run_formatting_import_formatNumber(formatting.fontSize)}pt`;
     if (formatting.color) span.style.color = formatting.color;
     if (formatting.backgroundColor) span.style.backgroundColor = formatting.backgroundColor;
     const html = span.outerHTML;
-    return html.slice(0, html.indexOf('>') + 1);
+    const tags = [
+        ...formatting.bold ? [
+            'strong'
+        ] : [],
+        ...formatting.italic ? [
+            'em'
+        ] : [],
+        ...formatting.underline ? [
+            'u'
+        ] : [],
+        ...formatting.strike ? [
+            's'
+        ] : []
+    ];
+    return {
+        start: `${html.slice(0, html.indexOf('>') + 1)}${tags.map((tag)=>`<${tag}>`).join('')}`,
+        end: `${[
+            ...tags
+        ].reverse().map((tag)=>`</${tag}>`).join('')}</span>`
+    };
+}
+function overriddenBoolean(current, next) {
+    return void 0 === next ? current : next;
+}
+function onOffProperty(properties, propertyName) {
+    const element = directChild(properties, propertyName);
+    if (!element) return;
+    const value = work_docx_run_formatting_import_wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function underlineProperty(properties) {
+    const element = directChild(properties, 'u');
+    if (!element) return;
+    const value = work_docx_run_formatting_import_wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value && 'none' !== value;
 }
 function directRunText(run) {
     return Array.from(run.children).filter((child)=>'t' === child.localName || 'delText' === child.localName).map((child)=>child.textContent ?? '').join('');
@@ -2151,6 +2508,61 @@ function assignFont(fonts, key, value) {
     const normalized = value?.trim();
     if (normalized) fonts[key] = normalized;
 }
+function resolvedFontHint(element) {
+    const hint = work_docx_run_formatting_import_wordAttribute(element, 'hint')?.trim().toLowerCase();
+    if ('eastasia' === hint) return 'eastAsia';
+    if ('cs' === hint) return 'complex';
+    if ('default' === hint) return 'ascii';
+}
+function orderedFonts(fonts, preferred) {
+    const order = {
+        ascii: [
+            'ascii',
+            'hAnsi',
+            'eastAsia',
+            'complex'
+        ],
+        hAnsi: [
+            'hAnsi',
+            'ascii',
+            'eastAsia',
+            'complex'
+        ],
+        eastAsia: [
+            'eastAsia',
+            'hAnsi',
+            'ascii',
+            'complex'
+        ],
+        complex: [
+            'complex',
+            'hAnsi',
+            'ascii',
+            'eastAsia'
+        ]
+    };
+    return order[preferred].map((slot)=>fonts[slot]);
+}
+function docxFontSlotForText(text, hint) {
+    for (const character of text){
+        const codePoint = character.codePointAt(0);
+        if (!(void 0 === codePoint || isNeutralCodePoint(codePoint))) {
+            if (isComplexScriptCodePoint(codePoint)) return 'complex';
+            if (isEastAsianCodePoint(codePoint)) return 'eastAsia';
+            return codePoint <= 0x7f ? 'ascii' : 'hAnsi';
+        }
+    }
+    return hint ?? 'ascii';
+}
+function isNeutralCodePoint(codePoint) {
+    return codePoint <= 0x20 || codePoint <= 0x7f && !(codePoint >= 0x41 && codePoint <= 0x5a || codePoint >= 0x61 && codePoint <= 0x7a) || codePoint >= 0x300 && codePoint <= 0x36f || codePoint >= 0x2000 && codePoint <= 0x206f;
+}
+function isComplexScriptCodePoint(codePoint) {
+    return codePoint >= 0x0590 && codePoint <= 0x08ff || codePoint >= 0xfb1d && codePoint <= 0xfdff || codePoint >= 0xfe70 && codePoint <= 0xfeff || codePoint >= 0x1ee00 && codePoint <= 0x1eeff;
+}
+function isEastAsianCodePoint(codePoint) {
+    return codePoint >= 0x1100 && codePoint <= 0x11ff || codePoint >= 0x2e80 && codePoint <= 0xa4cf || codePoint >= 0xac00 && codePoint <= 0xd7af || codePoint >= 0xf900 && codePoint <= 0xfaff || codePoint >= 0xfe10 && codePoint <= 0xfe6f || codePoint >= 0xff00 && codePoint <= 0xffef || codePoint >= 0x20000 && codePoint <= 0x323af;
+}
 function resolvedFont(element, explicitName, themeName, theme) {
     const explicit = work_docx_run_formatting_import_wordAttribute(element, explicitName);
     if (explicit?.trim()) return explicit;
@@ -2200,18 +2612,22 @@ function wordHighlightColor(value) {
 function work_docx_run_formatting_import_formatNumber(value) {
     return Number(value.toFixed(2)).toString();
 }
+function formatLineHeightFactor(value) {
+    return Number(value.toFixed(4)).toString();
+}
 const work_docx_tab_stop_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_tab_stop_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const work_docx_tab_stop_import_TWIPS_PER_CSS_PIXEL = 15;
 const PARAGRAPH_TAB_STOP_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_TAB_STOPS_\d+__/g;
 const INLINE_TAB_MARKER_PATTERN = /__A3S_WORK_INLINE_TAB_\d+__/g;
-function markDocxParagraphTabStops(document, styleSource) {
+function markDocxParagraphTabStops(document, styleSource, tableStyleSource) {
     const paragraphs = [];
     const inlineTabs = [];
     const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const paragraph of descendants(document, 'p')){
         let properties = directChild(paragraph, 'pPr');
-        const tabStops = resolvedParagraphTabStops(docxParagraphPropertySources(properties, styles));
+        const tabStops = resolvedParagraphTabStops(docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles)));
         if (tabStops.length) {
             properties ??= work_docx_tab_stop_import_insertParagraphProperties(document, paragraph);
             const marker = `__A3S_WORK_PARAGRAPH_TAB_STOPS_${paragraphs.length + 1}__`;
@@ -2357,20 +2773,42 @@ function work_docx_tab_stop_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
+const TABLE_BORDER_EDGES = [
+    'top',
+    'right',
+    'bottom',
+    'left'
+];
 const work_docx_table_cell_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_table_cell_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const TABLE_CELL_MARKER_PATTERN = /__A3S_WORK_TABLE_CELL_\d+__/g;
-function markDocxTableCells(document) {
+const PIXELS_PER_TWIP = 96 / 1440;
+function markDocxTableCells(document, themeSource, tableStyleSource) {
     const cells = [];
+    const theme = resolveDocxThemeResolver(themeSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const cell of descendants(document, 'tc')){
         const properties = directChild(cell, 'tcPr');
-        const shading = properties ? directChild(properties, 'shd') : void 0;
-        const verticalAlignment = properties ? directChild(properties, 'vAlign') : void 0;
-        const directBorders = properties ? uniformBorders(directChild(properties, 'tcBorders')) : null;
-        const border = directBorders ?? uniformTableBorders(cell);
-        const backgroundColor = ooxmlColor(attribute(shading ?? cell, 'fill'));
-        const verticalAlign = tableVerticalAlign(attribute(verticalAlignment ?? cell, 'val'));
-        if (!backgroundColor && !verticalAlign && !border) continue;
+        const table = work_docx_table_cell_import_closestAncestor(cell, 'tbl');
+        const directTableProperties = table ? directChild(table, 'tblPr') : void 0;
+        const layers = [
+            ...docxTableCellStyleLayers(cell, tableStyles),
+            ...directTableProperties ? [
+                {
+                    tableProperties: directTableProperties
+                }
+            ] : [],
+            ...properties ? [
+                {
+                    cellProperties: properties
+                }
+            ] : []
+        ];
+        const borders = importedTableCellBorders(cell, layers, theme);
+        const backgroundColor = importedTableCellBackgroundColor(layers, theme);
+        const verticalAlign = importedTableCellVerticalAlign(layers);
+        const margins = importedTableCellMargins(layers);
+        if (!backgroundColor && !verticalAlign && !borders && !margins) continue;
         const paragraph = firstTableCellParagraph(document, cell);
         if (!paragraph) continue;
         const marker = `__A3S_WORK_TABLE_CELL_${cells.length + 1}__`;
@@ -2383,10 +2821,11 @@ function markDocxTableCells(document) {
             ...verticalAlign ? {
                 verticalAlign
             } : {},
-            ...border ? {
-                borderColor: border.color,
-                borderStyle: border.style,
-                borderWidth: border.width
+            ...borders ? {
+                borders
+            } : {},
+            ...margins ? {
+                margins
             } : {}
         });
     }
@@ -2422,44 +2861,130 @@ function applyCellFormat(cell, format) {
         cell.dataset.officeCellVerticalAlign = format.verticalAlign;
         cell.style.verticalAlign = format.verticalAlign;
     }
-    if (format.borderColor && format.borderStyle && void 0 !== format.borderWidth) {
-        cell.dataset.officeCellBorderColor = format.borderColor;
-        cell.dataset.officeCellBorderStyle = format.borderStyle;
-        cell.dataset.officeCellBorderWidth = String(format.borderWidth);
-        cell.style.border = 'none' === format.borderStyle || 0 === format.borderWidth ? '0px none transparent' : `${format.borderWidth}px ${format.borderStyle} ${format.borderColor}`;
+    if (format.borders) {
+        const borders = documentTableBordersFromElement(cell, {
+            color: '#cfd5df',
+            style: 'solid',
+            width: 1
+        });
+        for (const edge of TABLE_BORDER_EDGES){
+            const border = format.borders[edge];
+            if (border) borders[edge] = {
+                ...border
+            };
+        }
+        const rendered = renderDocumentTableBorders(borders);
+        for (const [name, value] of Object.entries(rendered))if ('style' !== name) cell.setAttribute(name, value);
+        cell.style.cssText = `${cell.style.cssText}; ${rendered.style}`;
+    }
+    if (format.margins) {
+        const rendered = renderDocumentTableCellMarginOverrides(format.margins);
+        for (const [name, value] of Object.entries(rendered))if ('style' !== name) cell.setAttribute(name, value);
+        if (rendered.style) cell.style.cssText = `${cell.style.cssText}; ${rendered.style}`;
+    }
+}
+function importedTableCellMargins(layers) {
+    const margins = {};
+    for (const layer of layers){
+        const marginElement = layer.cellProperties ? directChild(layer.cellProperties, 'tcMar') : void 0;
+        if (!marginElement) continue;
+        const children = new Map(directChildren(marginElement).map((margin)=>[
+                margin.localName,
+                margin
+            ]));
+        assignCellMargin(margins, 'top', children.get('top'));
+        assignCellMargin(margins, 'right', children.get('right') ?? children.get('end'));
+        assignCellMargin(margins, 'bottom', children.get('bottom'));
+        assignCellMargin(margins, 'left', children.get('left') ?? children.get('start'));
+    }
+    return Object.keys(margins).length ? margins : null;
+}
+function assignCellMargin(target, side, element) {
+    if (!element) return;
+    const type = attribute(element, 'type');
+    if (type && 'dxa' !== type) return;
+    const twips = Number(attribute(element, 'w'));
+    if (!Number.isFinite(twips) || twips < 0) return;
+    target[side] = Math.round(twips * PIXELS_PER_TWIP * 100) / 100;
+}
+function importedTableCellBorders(cell, layers, theme) {
+    const borders = {};
+    for (const layer of layers){
+        if (layer.tableProperties) mergeBorders(borders, tableBordersForCell(cell, layer.tableProperties, theme));
+        if (layer.cellProperties) mergeBorders(borders, borderEdges(directChild(layer.cellProperties, 'tcBorders'), theme));
     }
+    return Object.keys(borders).length ? borders : null;
 }
-function uniformTableBorders(cell) {
+function tableBordersForCell(cell, properties, theme) {
     const table = work_docx_table_cell_import_closestAncestor(cell, 'tbl');
-    const properties = table ? directChild(table, 'tblPr') : void 0;
-    return properties ? uniformBorders(directChild(properties, 'tblBorders'), true) : null;
-}
-function uniformBorders(borders, includeInside = false) {
-    if (!borders) return null;
-    const edgeNames = includeInside ? [
-        'top',
-        'right',
-        'bottom',
-        'left',
-        'insideH',
-        'insideV'
-    ] : [
-        'top',
-        'right',
-        'bottom',
-        'left'
-    ];
-    const edgeElements = new Map(directChildren(borders).map((edge)=>[
+    const borders = borderElementMap(directChild(properties, 'tblBorders'));
+    if (!table || !borders.size) return {};
+    const row = work_docx_table_cell_import_closestAncestor(cell, 'tr');
+    if (!row) return {};
+    const rows = descendants(table, 'tr').filter((candidate)=>work_docx_table_cell_import_closestAncestor(candidate, 'tbl') === table);
+    const cells = descendants(row, 'tc').filter((candidate)=>work_docx_table_cell_import_closestAncestor(candidate, 'tr') === row);
+    const rowIndex = rows.indexOf(row);
+    const cellIndex = cells.indexOf(cell);
+    if (rowIndex < 0 || cellIndex < 0) return {};
+    return compactBorders({
+        top: parseBorder(borders.get(0 === rowIndex ? 'top' : 'insideH'), theme),
+        right: parseBorder(borderElement(borders, cellIndex === cells.length - 1 ? [
+            'right',
+            'end'
+        ] : [
+            'insideV'
+        ]), theme),
+        bottom: parseBorder(borders.get(rowIndex === rows.length - 1 ? 'bottom' : 'insideH'), theme),
+        left: parseBorder(borderElement(borders, 0 === cellIndex ? [
+            'left',
+            'start'
+        ] : [
+            'insideV'
+        ]), theme)
+    });
+}
+function mergeBorders(target, source) {
+    for (const edge of TABLE_BORDER_EDGES){
+        const border = source[edge];
+        if (border) target[edge] = border;
+    }
+}
+function borderEdges(borders, theme) {
+    const edges = borderElementMap(borders);
+    return compactBorders({
+        top: parseBorder(edges.get('top'), theme),
+        right: parseBorder(borderElement(edges, [
+            'right',
+            'end'
+        ]), theme),
+        bottom: parseBorder(edges.get('bottom'), theme),
+        left: parseBorder(borderElement(edges, [
+            'left',
+            'start'
+        ]), theme)
+    });
+}
+function borderElementMap(borders) {
+    return new Map(borders ? directChildren(borders).map((edge)=>[
             edge.localName,
             edge
-        ]));
-    const formats = edgeNames.map((name)=>parseBorder(edgeElements.get(name)));
-    if (formats.some((format)=>!format)) return null;
-    const first = formats[0];
-    if (!first) return null;
-    return formats.every((format)=>format?.color === first.color && format.style === first.style && format.width === first.width) ? first : null;
+        ]) : []);
+}
+function borderElement(borders, names) {
+    for (const name of names){
+        const edge = borders.get(name);
+        if (edge) return edge;
+    }
 }
-function parseBorder(edge) {
+function compactBorders(borders) {
+    const result = {};
+    for (const edge of TABLE_BORDER_EDGES){
+        const border = borders[edge];
+        if (border) result[edge] = border;
+    }
+    return result;
+}
+function parseBorder(edge, theme) {
     if (!edge) return null;
     const style = tableBorderStyle(attribute(edge, 'val'));
     if (!style) return null;
@@ -2468,7 +2993,8 @@ function parseBorder(edge) {
         style,
         width: 0
     };
-    const color = ooxmlColor(attribute(edge, 'color')) ?? '#000000';
+    const themed = docxThemeColor(theme, attribute(edge, 'themeColor'), attribute(edge, 'themeTint'), attribute(edge, 'themeShade'));
+    const color = themed ? `#${themed}` : ooxmlColor(attribute(edge, 'color')) ?? '#000000';
     const size = Number(attribute(edge, 'sz'));
     const width = Number.isFinite(size) && size > 0 ? size / 6 : 1;
     return {
@@ -2477,6 +3003,30 @@ function parseBorder(edge) {
         width: Math.max(0.5, Math.min(6, Math.round(2 * width) / 2))
     };
 }
+function importedTableCellBackgroundColor(layers, theme) {
+    let color = null;
+    for (const layer of layers){
+        const tableShading = layer.tableProperties ? directChild(layer.tableProperties, 'shd') : void 0;
+        const cellShading = layer.cellProperties ? directChild(layer.cellProperties, 'shd') : void 0;
+        if (tableShading) color = tableCellBackgroundColor(tableShading, theme);
+        if (cellShading) color = tableCellBackgroundColor(cellShading, theme);
+    }
+    return color;
+}
+function tableCellBackgroundColor(shading, theme) {
+    const themed = docxThemeColor(theme, attribute(shading, 'themeFill'), attribute(shading, 'themeFillTint'), attribute(shading, 'themeFillShade'));
+    return themed ? `#${themed}` : ooxmlColor(attribute(shading, 'fill'));
+}
+function importedTableCellVerticalAlign(layers) {
+    let alignment = null;
+    for (const layer of layers){
+        const element = layer.cellProperties ? directChild(layer.cellProperties, 'vAlign') : void 0;
+        if (!element) continue;
+        const value = tableVerticalAlign(attribute(element, 'val'));
+        if (value) alignment = value;
+    }
+    return alignment;
+}
 function tableBorderStyle(value) {
     const normalized = value?.trim();
     if (!normalized) return null;
@@ -2532,7 +3082,7 @@ function work_docx_table_cell_import_textNodes(root) {
 const work_docx_table_row_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_table_row_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const TABLE_ROW_MARKER_PATTERN = /__A3S_WORK_TABLE_ROW_\d+__/g;
-const PIXELS_PER_TWIP = 96 / 1440;
+const work_docx_table_row_import_PIXELS_PER_TWIP = 96 / 1440;
 function markDocxTableRows(document) {
     const rows = [];
     for (const row of descendants(document, 'tr')){
@@ -2625,7 +3175,7 @@ function tableRowHeightRule(value) {
 }
 function work_docx_table_row_import_twipsToPixels(value) {
     if (!Number.isFinite(value) || value <= 0) return null;
-    return Math.round(value * PIXELS_PER_TWIP * 100) / 100;
+    return Math.round(value * work_docx_table_row_import_PIXELS_PER_TWIP * 100) / 100;
 }
 function work_docx_table_row_import_closestAncestor(element, localName) {
     let current = element;
@@ -2647,21 +3197,19 @@ const work_docx_table_sizing_import_WORD_NAMESPACE = 'http://schemas.openxmlform
 const work_docx_table_sizing_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const TABLE_SIZING_MARKER_PATTERN = /__A3S_WORK_TABLE_SIZING_\d+__/g;
 const work_docx_table_sizing_import_PIXELS_PER_TWIP = 96 / 1440;
-function markDocxTableSizing(document) {
+function markDocxTableSizing(document, tableStyleSource) {
     const tables = [];
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
     for (const table of descendants(document, 'tbl')){
         const paragraph = firstTableParagraph(document, table);
         if (!paragraph) continue;
-        const properties = directChild(table, 'tblPr');
-        const layout = properties ? directChild(properties, 'tblLayout') : void 0;
-        const preferredWidth = properties ? directChild(properties, 'tblW') : void 0;
         const grid = directChild(table, 'tblGrid');
-        const columnWidths = grid ? directChildren(grid, 'gridCol').map((column)=>work_docx_table_sizing_import_twipsToPixels(Number(attribute(column, 'w')))).filter((width)=>null !== width) : [];
+        const columnWidths = grid ? directChildren(grid, 'gridCol').map((column)=>work_docx_table_sizing_import_twipsToPixels(Number(attribute(column, 'w')), false)).filter((width)=>null !== width) : [];
         const marker = `__A3S_WORK_TABLE_SIZING_${tables.length + 1}__`;
         insertMarker(document, paragraph, marker);
         tables.push({
             marker,
-            layoutMode: importedTableLayoutMode(layout, preferredWidth),
+            geometry: importedTableGeometry(docxTablePropertySources(table, tableStyles)),
             columnWidths
         });
     }
@@ -2680,8 +3228,9 @@ function applyImportedDocxTableSizingMarkers(document, markers) {
         node.data = node.data.replace(TABLE_SIZING_MARKER_PATTERN, (marker)=>{
             const sizing = tableByMarker.get(marker);
             if (table instanceof HTMLTableElement && sizing) {
-                table.dataset.officeTableLayout = sizing.layoutMode;
-                if ('fixed' === sizing.layoutMode && sizing.columnWidths.length) applyColumnWidths(table, sizing.columnWidths);
+                table.dataset.officeTableImported = 'true';
+                applyDocumentTableGeometryToElement(table, sizing.geometry);
+                if (sizing.columnWidths.length) applyColumnWidths(table, sizing.columnWidths);
             }
             return '';
         });
@@ -2691,12 +3240,104 @@ function applyImportedDocxTableSizingMarkers(document, markers) {
 function hasImportedDocxTableSizingMarkers(markers) {
     return markers.tables.length > 0;
 }
-function importedTableLayoutMode(layout, preferredWidth) {
-    const layoutType = layout ? attribute(layout, 'type') : null;
-    const widthType = preferredWidth ? attribute(preferredWidth, 'type') : null;
-    if ('autofit' === layoutType || 'auto' === widthType) return 'contents';
-    if ('pct' === widthType) return 'window';
-    return 'fixed';
+function importedTableGeometry(propertySources) {
+    let layout = DEFAULT_DOCUMENT_TABLE_GEOMETRY.layout;
+    let width = {
+        type: 'auto',
+        value: null
+    };
+    let alignment = DEFAULT_DOCUMENT_TABLE_GEOMETRY.alignment;
+    let indent = DEFAULT_DOCUMENT_TABLE_GEOMETRY.indent;
+    let cellMargins = {
+        ...DEFAULT_DOCUMENT_TABLE_CELL_MARGINS
+    };
+    for (const properties of propertySources){
+        const layoutElement = directChild(properties, 'tblLayout');
+        const layoutValue = layoutElement ? importedTableLayout(attribute(layoutElement, 'type')) : null;
+        if (layoutValue) layout = layoutValue;
+        const widthElement = directChild(properties, 'tblW');
+        const widthValue = widthElement ? importedTablePreferredWidth(widthElement) : null;
+        if (widthValue) width = widthValue;
+        const alignmentElement = directChild(properties, 'jc');
+        const alignmentValue = alignmentElement ? importedTableAlignment(attribute(alignmentElement, 'val')) : null;
+        if (alignmentValue) alignment = alignmentValue;
+        const indentElement = directChild(properties, 'tblInd');
+        const indentValue = indentElement ? tableWidthPixels(indentElement, true) : null;
+        if (null !== indentValue) indent = indentValue;
+        const marginElement = directChild(properties, 'tblCellMar');
+        if (marginElement) cellMargins = {
+            ...cellMargins,
+            ...importedCellMargins(marginElement)
+        };
+    }
+    return {
+        layout,
+        width,
+        alignment,
+        indent,
+        cellMargins
+    };
+}
+function importedTableLayout(value) {
+    if ('fixed' === value) return 'fixed';
+    return 'autofit' === value ? 'autofit' : null;
+}
+function importedTablePreferredWidth(width) {
+    const type = attribute(width, 'type');
+    if ('auto' === type || 'nil' === type) return {
+        type: 'auto',
+        value: null
+    };
+    if ('pct' === type) {
+        const value = percentageValue(attribute(width, 'w'));
+        return null === value ? null : {
+            type: 'percent',
+            value
+        };
+    }
+    if ('dxa' === type) {
+        const value = tableWidthPixels(width, false);
+        return null === value ? null : {
+            type: 'pixels',
+            value
+        };
+    }
+    return null;
+}
+function importedTableAlignment(value) {
+    if ('center' === value) return 'center';
+    if ('right' === value || 'end' === value) return 'right';
+    if ('left' === value || 'start' === value) return 'left';
+    return null;
+}
+function importedCellMargins(margins) {
+    const children = new Map(directChildren(margins).map((margin)=>[
+            margin.localName,
+            margin
+        ]));
+    const result = {};
+    assignMargin(result, 'top', children.get('top'));
+    assignMargin(result, 'right', children.get('right') ?? children.get('end'));
+    assignMargin(result, 'bottom', children.get('bottom'));
+    assignMargin(result, 'left', children.get('left') ?? children.get('start'));
+    return result;
+}
+function assignMargin(target, side, element) {
+    if (!element) return;
+    const value = tableWidthPixels(element, true);
+    if (null !== value) target[side] = value;
+}
+function tableWidthPixels(element, allowZero) {
+    const type = attribute(element, 'type');
+    if (type && 'dxa' !== type) return null;
+    return work_docx_table_sizing_import_twipsToPixels(Number(attribute(element, 'w')), allowZero);
+}
+function percentageValue(value) {
+    const normalized = value?.trim();
+    if (!normalized) return null;
+    const percentage = normalized.endsWith('%') ? Number(normalized.slice(0, -1)) : Number(normalized) / 50;
+    if (!Number.isFinite(percentage) || percentage <= 0) return null;
+    return Math.round(100 * percentage) / 100;
 }
 function applyColumnWidths(table, columnWidths) {
     const occupiedUntilRow = [];
@@ -2729,8 +3370,8 @@ function insertMarker(document, paragraph, marker) {
     const properties = directChild(paragraph, 'pPr');
     paragraph.insertBefore(run, properties?.nextSibling ?? paragraph.firstChild);
 }
-function work_docx_table_sizing_import_twipsToPixels(value) {
-    if (!Number.isFinite(value) || value <= 0) return null;
+function work_docx_table_sizing_import_twipsToPixels(value, allowZero) {
+    if (!Number.isFinite(value) || value < 0 || !allowZero && 0 === value) return null;
     return Math.round(value * work_docx_table_sizing_import_PIXELS_PER_TWIP * 100) / 100;
 }
 function work_docx_table_sizing_import_closestAncestor(element, localName) {
@@ -2838,18 +3479,19 @@ async function prepareDocxImport(buffer) {
     const imageLayoutMarkers = markDocxImageLayouts(document);
     const paragraphStylesDocument = archive.has('word/styles.xml') ? await archive.xml('word/styles.xml') : null;
     const paragraphStyles = createDocxParagraphStyleResolver(paragraphStylesDocument);
-    const paragraphDirectionMarkers = markDocxParagraphDirections(document, paragraphStyles);
-    const paragraphAlignmentMarkers = markDocxParagraphAlignments(document, paragraphStyles);
-    const paragraphIndentMarkers = markDocxParagraphIndents(document, paragraphStyles);
-    const paragraphSpacingMarkers = markDocxParagraphSpacing(document, paragraphStyles);
-    const paragraphPaginationMarkers = markDocxParagraphPagination(document, paragraphStyles);
+    const tableStyles = createDocxTableStyleResolver(paragraphStylesDocument);
+    const paragraphDirectionMarkers = markDocxParagraphDirections(document, paragraphStyles, tableStyles);
+    const paragraphAlignmentMarkers = markDocxParagraphAlignments(document, paragraphStyles, tableStyles);
+    const paragraphIndentMarkers = markDocxParagraphIndents(document, paragraphStyles, tableStyles);
+    const paragraphSpacingMarkers = markDocxParagraphSpacing(document, paragraphStyles, tableStyles);
+    const paragraphPaginationMarkers = markDocxParagraphPagination(document, paragraphStyles, tableStyles);
     const themePath = archive.paths('word/theme/').find((path)=>/\/theme\d*\.xml$/i.test(path));
     const themeDocument = themePath ? await archive.xml(themePath) : null;
-    const runFormattingMarkers = markDocxRunFormatting(document, paragraphStyles, themeDocument);
-    const tabStopMarkers = markDocxParagraphTabStops(document, paragraphStyles);
-    const tableCellMarkers = markDocxTableCells(document);
+    const runFormattingMarkers = markDocxRunFormatting(document, paragraphStyles, themeDocument, tableStyles);
+    const tabStopMarkers = markDocxParagraphTabStops(document, paragraphStyles, tableStyles);
+    const tableCellMarkers = markDocxTableCells(document, themeDocument, tableStyles);
     const tableRowMarkers = markDocxTableRows(document);
-    const tableSizingMarkers = markDocxTableSizing(document);
+    const tableSizingMarkers = markDocxTableSizing(document, tableStyles);
     const settings = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
     const trackChanges = Boolean(settings && firstDescendant(settings, 'trackRevisions')) || changeMarkers.changes.length > 0;
     const sectionElements = effectiveSectionProperties(document);
@@ -3021,6 +3663,7 @@ async function parseSectionLayout(section, archive, relationships, previous, odd
     const size = pageSize ? Math.abs(shortEdge - 12240) < Math.abs(shortEdge - 11906) ? 'letter' : 'a4' : previous.pageSize;
     const marginsElement = firstDescendant(section, 'pgMar');
     const columnsElement = firstDescendant(section, 'cols');
+    const documentGridElement = directChild(section, 'docGrid');
     const pageChrome = await importSectionPageChrome(section, archive, relationships, previous, oddEvenPageChrome);
     const pageNumberStart = work_docx_import_numberAttribute(firstDescendant(section, 'pgNumType'), 'start');
     return {
@@ -3032,11 +3675,27 @@ async function parseSectionLayout(section, archive, relationships, previous, odd
         columns: columnsElement ? importDocxColumns(columnsElement, previous.columns) : {
             ...previous.columns
         },
+        ...documentGridElement ? {
+            documentGrid: parseDocumentGrid(documentGridElement)
+        } : previous.documentGrid ? {
+            documentGrid: {
+                ...previous.documentGrid
+            }
+        } : {},
         breakAfter: parseSectionBreak(firstDescendant(section, 'type')),
         ...pageChrome,
         pageNumberStart: pageNumberStart > 0 ? pageNumberStart : void 0
     };
 }
+function parseDocumentGrid(element) {
+    const sourceType = attribute(element, 'type');
+    const type = 'lines' === sourceType || 'linesAndChars' === sourceType || 'snapToChars' === sourceType ? sourceType : 'default';
+    const sourceLinePitch = work_docx_import_numberAttribute(element, 'linePitch');
+    return {
+        type,
+        linePitch: sourceLinePitch > 0 ? Number((sourceLinePitch / 20).toFixed(2)) : 18
+    };
+}
 function addSectionMarkers(document, sectionElements) {
     for(let index = 0; index < sectionElements.length - 1; index += 1){
         const paragraph = work_docx_import_closestAncestor(sectionElements[index], 'p');