@a3s-lab/office 0.2.2 → 0.4.0

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

@@ -1,13 +1,281 @@
 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 "./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";
+import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, attribute } from "./5184.js";
+import { normalizeDocumentBookmarkName, renderDocumentTableCellMarginOverrides, applyDocumentImageIdentityToElement, normalizeDocumentTabStops, createDocumentImageIdentityRegistry, normalizeDocumentColumns, normalizeDocumentImageWrapContour, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, normalizeDocumentBookmarksHtml, applyDocumentTableRowIdentityToElement, normalizeDocumentCaptionsHtml, normalizeDocumentImageAlignment, normalizeDocumentParagraphId, applyDocumentImageLayerToElement, normalizeDocumentNotesHtml, normalizeDocumentBookmarkReferencesHtml, documentCitationTagsFromInstruction, applyDocumentImageWrapContourToElement, renderDocumentAutoLineHeight, applyDocumentPageGeometry, normalizeDocumentPageChrome, normalizeDocumentImageLayoutOptions, applyDocumentImageCropToElement, documentPageMarginsForLayout, createDocumentNoteElement, serializeDocumentTabStops, normalizeDocumentImageLayer, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, documentBookmarkReferenceInstruction, documentInitialSectionLayout, normalizeDocumentFieldsHtml, documentCaptionLabel, documentTableBordersFromElement, isContourImageLayout, normalizeDocumentCitationsHtml, normalizeDocumentImageIdentity, normalizeDocumentImageWrapSide, applyDocumentParagraphIdentityToElement, documentAutoLineHeight, docxDocumentFieldKind, serializeDocxThemeReference, renderDocumentTableBorders, docxBookmarkReferenceTarget, normalizeDocumentImagePosition, wrapsBesideImage, documentPageChromeLegacyFields, documentParagraphShadingDomAttributes, DEFAULT_DOCUMENT_TABLE_GEOMETRY, documentParagraphBordersDomAttributes, documentSectionDomAttributes, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, normalizeDocumentParagraphIdentity, documentPageMarginBody, normalizeDocumentParagraphIndent, normalizeDocumentTableRowIdentity, normalizeDocumentBookmarkNativeId, uniqueDocumentImageIdentity, applyDocumentTableGeometryToElement, normalizeDocumentImageCrop, documentContentLayoutProperties, documentWordLineHeightFactor } from "./8928.js";
+import { parseDocxPageMargins, parseDocxPageGeometry, parseDocxPageBorders, docxCaptionReferenceTarget, applyImportedDocxEquationMarkers, createDocxTableStyleResolver, hasImportedDocxParagraphShadingMarkers, isDocxEquationLikeRoot, inspectDocxPageMarginSettings, docxTableRunPropertySources, docxParagraphPropertySources, docxCaptionSequenceKind, resolveDocxParagraphBordersForParagraph, applyImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphBorderMarkers, docxCaptionBookmark, docxFieldResultText, resolveDocxParagraphStyleResolver, createDocxParagraphStyleResolver, docxEquationHtml, docxFieldOccurrences, docxTableParagraphPropertySources, resolveDocxTableStyleResolver, docxTableCellStyleLayers, markDocxParagraphBorders, docxFieldOccurrenceIsInlineEditable, applyImportedDocxParagraphBorderMarkers, parseDocxPaperSource, docxTablePropertySources, docxRunPropertySources, parseDirectDocxParagraphShading, markDocxParagraphShading, markDocxPackageEquations } from "./0~7754.js";
+import { xmlAttributeLocalName, docxThemeFont, readDocxBibliography, createDocxThemeResolver, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace } from "./0~2805.js";
+import { importDocxPageColor, importedDocumentNoteId } from "./0~4980.js";
 const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const MAX_BOOKMARK_NAME_LENGTH = 40;
+const MAX_BOOKMARK_NATIVE_ID = 0x7fffffff;
+function markDocxBookmarks(document) {
+    const captionBookmarks = captionBookmarkStarts(document);
+    const captionNames = new Set(Array.from(captionBookmarks).map((bookmark)=>attribute(bookmark, 'name')?.trim().toLowerCase()).filter((name)=>Boolean(name)));
+    const pairs = docxBookmarkPairs(document).filter((pair)=>!captionBookmarks.has(pair.start) && '_GoBack' !== pair.sourceName);
+    const names = new Set();
+    const normalizedNames = new Map();
+    for(let index = pairs.length - 1; index >= 0; index -= 1){
+        const pair = pairs[index];
+        if (!pair) continue;
+        const base = normalizeDocumentBookmarkName(pair.sourceName) ?? safeImportedBookmarkName(pair.sourceName, index + 1);
+        const name = uniqueImportedBookmarkName(base, names);
+        names.add(name.toLowerCase());
+        normalizedNames.set(pair, name);
+    }
+    const nativeIds = new Set();
+    const internalIds = new Set();
+    const bookmarks = [];
+    for (const [index, pair] of pairs.entries()){
+        const preferredNativeId = normalizeDocumentBookmarkNativeId(pair.sourceNativeId);
+        const nativeId = null === preferredNativeId || nativeIds.has(preferredNativeId) ? nextNativeId(nativeIds) : preferredNativeId;
+        nativeIds.add(nativeId);
+        const name = normalizedNames.get(pair) ?? `Bookmark_${index + 1}`;
+        const id = uniqueImportedBookmarkId(name, nativeId, index + 1, internalIds);
+        internalIds.add(id);
+        const marker = importedBookmarkMarker(index + 1, id, name, pair.sourceName, nativeId, document.documentElement.textContent ?? '');
+        insertBoundaryMarker(document, pair.start, marker.start);
+        insertBoundaryMarker(document, pair.end, marker.end);
+        pair.start.remove();
+        pair.end.remove();
+        bookmarks.push(marker);
+    }
+    const targets = new Map();
+    for (const bookmark of bookmarks)targets.set(bookmark.sourceName.toLowerCase(), bookmark);
+    const references = docxFieldOccurrences(document).flatMap((field, index)=>{
+        const sourceTarget = docxBookmarkReferenceTarget(field.instruction);
+        const target = sourceTarget ? targets.get(sourceTarget.toLowerCase()) : null;
+        if (!sourceTarget || !target || captionNames.has(sourceTarget.toLowerCase()) || !canMarkField(field)) return [];
+        const marker = importedBookmarkReferenceMarker(index + 1, target, field.instruction, docxFieldResultText(field), document.documentElement.textContent ?? '');
+        insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
+        return [
+            marker
+        ];
+    });
+    return {
+        bookmarks,
+        references
+    };
+}
+function applyImportedDocxBookmarkMarkers(document, markers) {
+    for (const reference of markers.references){
+        const element = document.createElement('span');
+        element.dataset.documentCrossReference = 'true';
+        element.dataset.referenceTargetType = 'bookmark';
+        element.dataset.referenceTargetId = reference.targetId;
+        element.dataset.referenceTargetName = reference.targetName;
+        element.dataset.referenceInstruction = reference.instruction;
+        const convertedDisplay = replaceBookmarkReferenceMarkerRange(document.body, reference.start, reference.end, element);
+        const display = reference.display.trim() || convertedDisplay.trim() || reference.targetName;
+        element.dataset.referenceDisplay = display;
+        element.className = 'work-document-cross-reference';
+        element.textContent = display;
+    }
+    const targetNames = new Map();
+    for (const bookmark of markers.bookmarks){
+        targetNames.set(bookmark.sourceName.toLowerCase(), bookmark.name);
+        replaceBookmarkMarker(document.body, bookmark.start, {
+            ...bookmark,
+            kind: 'start'
+        });
+        replaceBookmarkMarker(document.body, bookmark.end, {
+            ...bookmark,
+            kind: 'end'
+        });
+    }
+    for (const link of document.body.querySelectorAll('a[href^="#"]')){
+        const sourceName = (link.getAttribute('href') ?? '').slice(1);
+        const name = targetNames.get(sourceName.toLowerCase());
+        if (name) link.setAttribute('href', `#${name}`);
+    }
+}
+function hasImportedDocxBookmarkMarkers(markers) {
+    return markers.bookmarks.length > 0 || markers.references.length > 0;
+}
+function docxBookmarkPairs(document) {
+    const open = new Map();
+    const pairs = [];
+    for (const element of Array.from(document.getElementsByTagName('*'))){
+        if ('bookmarkStart' === element.localName) {
+            const id = attribute(element, 'id')?.trim() ?? '';
+            const stack = open.get(id) ?? [];
+            stack.push(element);
+            open.set(id, stack);
+            continue;
+        }
+        if ('bookmarkEnd' !== element.localName) continue;
+        const id = attribute(element, 'id')?.trim() ?? '';
+        const start = open.get(id)?.pop();
+        if (start) pairs.push({
+            start,
+            end: element,
+            sourceName: attribute(start, 'name')?.trim() ?? '',
+            sourceNativeId: id
+        });
+    }
+    pairs.sort((left, right)=>{
+        const position = left.start.compareDocumentPosition(right.start);
+        if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+        if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+        return 0;
+    });
+    return pairs;
+}
+function captionBookmarkStarts(document) {
+    const bookmarks = new Set();
+    for (const paragraph of descendants(document, 'p'))for (const field of docxFieldOccurrences(paragraph)){
+        if (!docxCaptionSequenceKind(field.instruction)) continue;
+        const bookmark = docxCaptionBookmark(paragraph, field);
+        if (bookmark) bookmarks.add(bookmark);
+    }
+    return bookmarks;
+}
+function importedBookmarkMarker(index, id, name, sourceName, nativeId, occupiedText) {
+    const base = `${index}_${stableHash(`${id}:${name}`)}`;
+    let suffix = base;
+    let collision = 2;
+    while(occupiedText.includes(`__A3S_WORK_BOOKMARK_START_${suffix}__`) || occupiedText.includes(`__A3S_WORK_BOOKMARK_END_${suffix}__`)){
+        suffix = `${base}_${collision}`;
+        collision += 1;
+    }
+    return {
+        start: `__A3S_WORK_BOOKMARK_START_${suffix}__`,
+        end: `__A3S_WORK_BOOKMARK_END_${suffix}__`,
+        id,
+        name,
+        sourceName,
+        nativeId
+    };
+}
+function importedBookmarkReferenceMarker(index, target, sourceInstruction, display, occupiedText) {
+    const base = `${index}_${stableHash(`${target.id}:${sourceInstruction}`)}`;
+    let suffix = base;
+    let collision = 2;
+    while(occupiedText.includes(`__A3S_WORK_BOOKMARK_REFERENCE_START_${suffix}__`) || occupiedText.includes(`__A3S_WORK_BOOKMARK_REFERENCE_END_${suffix}__`)){
+        suffix = `${base}_${collision}`;
+        collision += 1;
+    }
+    return {
+        start: `__A3S_WORK_BOOKMARK_REFERENCE_START_${suffix}__`,
+        end: `__A3S_WORK_BOOKMARK_REFERENCE_END_${suffix}__`,
+        targetId: target.id,
+        targetName: target.name,
+        instruction: documentBookmarkReferenceInstruction(target.name, sourceInstruction),
+        display
+    };
+}
+function insertBoundaryMarker(document, boundary, marker) {
+    boundary.parentNode?.insertBefore(work_docx_bookmark_import_markerRun(document, marker), boundary);
+}
+function insertFieldBoundaryMarkers(document, field, start, end) {
+    if ('fldChar' === field.start.localName && 'fldChar' === field.end.localName) {
+        field.start.parentNode?.insertBefore(markerText(document, start), field.start);
+        field.end.parentNode?.insertBefore(markerText(document, end), field.end.nextSibling);
+        return;
+    }
+    field.start.parentNode?.insertBefore(work_docx_bookmark_import_markerRun(document, start), field.start);
+    field.end.parentNode?.insertBefore(work_docx_bookmark_import_markerRun(document, end), field.end.nextSibling);
+}
+function work_docx_bookmark_import_markerRun(document, marker) {
+    const run = document.createElementNS(WORD_NAMESPACE, 'w:r');
+    run.append(markerText(document, marker));
+    return run;
+}
+function markerText(document, marker) {
+    const text = document.createElementNS(WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    return text;
+}
+function replaceBookmarkMarker(root, marker, bookmark) {
+    const text = textNodes(root).find((node)=>node.data.includes(marker));
+    if (!text) return false;
+    const offset = text.data.indexOf(marker);
+    const element = root.ownerDocument.createElement('span');
+    element.dataset.documentBookmarkBoundary = 'true';
+    element.dataset.bookmarkKind = bookmark.kind;
+    element.dataset.bookmarkId = bookmark.id;
+    element.dataset.bookmarkName = bookmark.name;
+    element.dataset.officeBookmarkId = String(bookmark.nativeId);
+    element.className = `work-document-bookmark-boundary ${bookmark.kind}`;
+    element.contentEditable = 'false';
+    element.setAttribute('aria-hidden', 'true');
+    if ('start' === bookmark.kind) element.id = bookmark.name;
+    const before = text.data.slice(0, offset);
+    const after = text.data.slice(offset + marker.length);
+    const fragment = root.ownerDocument.createDocumentFragment();
+    if (before) fragment.append(root.ownerDocument.createTextNode(before));
+    fragment.append(element);
+    if (after) fragment.append(root.ownerDocument.createTextNode(after));
+    text.replaceWith(fragment);
+    return true;
+}
+function replaceBookmarkReferenceMarkerRange(root, start, end, replacement) {
+    const nodes = textNodes(root);
+    const startNode = nodes.find((node)=>node.data.includes(start));
+    const endNode = nodes.find((node)=>node.data.includes(end));
+    if (!startNode || !endNode) return '';
+    const range = root.ownerDocument.createRange();
+    range.setStart(startNode, startNode.data.indexOf(start));
+    range.setEnd(endNode, endNode.data.indexOf(end) + end.length);
+    const content = range.cloneContents();
+    removeMarkerText(content, start);
+    removeMarkerText(content, end);
+    const display = content.textContent ?? '';
+    range.deleteContents();
+    range.insertNode(replacement);
+    return display;
+}
+function removeMarkerText(root, marker) {
+    for (const node of textNodes(root))node.data = node.data.replace(marker, '');
+}
+function canMarkField(field) {
+    return field.start !== field.end || 'fldSimple' === field.start.localName;
+}
+function safeImportedBookmarkName(source, index) {
+    const characters = Array.from(source.trim()).map((character)=>/^[\p{L}\p{N}_]$/u.test(character) ? character : '_').join('');
+    const leading = /^[\p{L}_]/u.test(characters) ? characters : `Bookmark_${characters}`;
+    return Array.from(leading || `Bookmark_${index}`).slice(0, MAX_BOOKMARK_NAME_LENGTH).join('') || `Bookmark_${index}`;
+}
+function uniqueImportedBookmarkName(base, names) {
+    if (!names.has(base.toLowerCase())) return base;
+    let suffix = 2;
+    while(suffix <= MAX_BOOKMARK_NATIVE_ID){
+        const ending = `_${suffix}`;
+        const prefix = Array.from(base).slice(0, MAX_BOOKMARK_NAME_LENGTH - ending.length).join('');
+        const candidate = `${prefix}${ending}`;
+        if (!names.has(candidate.toLowerCase())) return candidate;
+        suffix += 1;
+    }
+    throw new Error('No unique imported Word bookmark name is available.');
+}
+function uniqueImportedBookmarkId(name, nativeId, index, ids) {
+    const base = `docx-bookmark-${nativeId}-${stableHash(name)}`;
+    if (!ids.has(base)) return base;
+    let suffix = index;
+    while(ids.has(`${base}-${suffix}`))suffix += 1;
+    return `${base}-${suffix}`;
+}
+function nextNativeId(ids) {
+    for(let id = 0; id <= MAX_BOOKMARK_NATIVE_ID; id += 1)if (!ids.has(id)) return id;
+    throw new Error('No unique imported Word bookmark identifier is available.');
+}
+function stableHash(source) {
+    let hash = 0x811c9dc5;
+    for(let index = 0; index < source.length; index += 1){
+        hash ^= source.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+function textNodes(root) {
+    const walker = root.ownerDocument?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+const work_docx_caption_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_caption_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 function markDocxCaptionFields(document) {
     const captions = [];
     const bookmarkTargets = new Map();
@@ -32,7 +300,7 @@ function markDocxCaptionFields(document) {
         const targetId = bookmarkName ? bookmarkTargets.get(bookmarkName) : void 0;
         if (!targetId) continue;
         const marker = referenceMarker(references.length + 1, targetId);
-        insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
+        work_docx_caption_import_insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
         references.push(marker);
     }
     return {
@@ -50,8 +318,8 @@ function applyImportedDocxCaptionMarkers(document, markers) {
     for (const caption of markers.captions){
         const block = markerBlock(document.body, caption.start, caption.end);
         if (!block) continue;
-        removeMarkerText(block, caption.start);
-        removeMarkerText(block, caption.end);
+        work_docx_caption_import_removeMarkerText(block, caption.start);
+        work_docx_caption_import_removeMarkerText(block, caption.end);
         removeCaptionPrefix(block, caption.kind);
         const element = document.createElement('figcaption');
         element.dataset.documentCaption = 'true';
@@ -93,29 +361,29 @@ function insertParagraphBoundaryMarkers(document, paragraph, start, end) {
     paragraph.insertBefore(work_docx_caption_import_markerRun(document, start), firstContent ?? null);
     paragraph.append(work_docx_caption_import_markerRun(document, end));
 }
-function insertFieldBoundaryMarkers(document, field, start, end) {
+function work_docx_caption_import_insertFieldBoundaryMarkers(document, field, start, end) {
     if ('fldChar' === field.start.localName && 'fldChar' === field.end.localName) {
-        field.start.parentNode?.insertBefore(markerText(document, start), field.start);
-        field.end.parentNode?.insertBefore(markerText(document, end), field.end.nextSibling);
+        field.start.parentNode?.insertBefore(work_docx_caption_import_markerText(document, start), field.start);
+        field.end.parentNode?.insertBefore(work_docx_caption_import_markerText(document, end), field.end.nextSibling);
         return;
     }
     field.start.parentNode?.insertBefore(work_docx_caption_import_markerRun(document, start), field.start);
     field.end.parentNode?.insertBefore(work_docx_caption_import_markerRun(document, end), field.end.nextSibling);
 }
 function work_docx_caption_import_markerRun(document, text) {
-    const run = document.createElementNS(WORD_NAMESPACE, 'w:r');
-    run.append(markerText(document, text));
+    const run = document.createElementNS(work_docx_caption_import_WORD_NAMESPACE, 'w:r');
+    run.append(work_docx_caption_import_markerText(document, text));
     return run;
 }
-function markerText(document, text) {
-    const value = document.createElementNS(WORD_NAMESPACE, 'w:t');
-    value.setAttributeNS(XML_NAMESPACE, 'xml:space', 'preserve');
+function work_docx_caption_import_markerText(document, text) {
+    const value = document.createElementNS(work_docx_caption_import_WORD_NAMESPACE, 'w:t');
+    value.setAttributeNS(work_docx_caption_import_XML_NAMESPACE, 'xml:space', 'preserve');
     value.textContent = text;
     return value;
 }
 function markerBlock(root, start, end) {
-    const startNode = textNodes(root).find((node)=>node.data.includes(start));
-    const endNode = textNodes(root).find((node)=>node.data.includes(end));
+    const startNode = work_docx_caption_import_textNodes(root).find((node)=>node.data.includes(start));
+    const endNode = work_docx_caption_import_textNodes(root).find((node)=>node.data.includes(end));
     if (!startNode || !endNode) return null;
     let current = startNode.parentElement;
     while(current && current !== root){
@@ -125,7 +393,7 @@ function markerBlock(root, start, end) {
     return null;
 }
 function replaceMarkerRange(root, start, end, replacement) {
-    const nodes = textNodes(root);
+    const nodes = work_docx_caption_import_textNodes(root);
     const startNode = nodes.find((node)=>node.data.includes(start));
     const endNode = nodes.find((node)=>node.data.includes(end));
     if (!startNode || !endNode) return false;
@@ -136,8 +404,8 @@ function replaceMarkerRange(root, start, end, replacement) {
     range.insertNode(replacement);
     return true;
 }
-function removeMarkerText(root, marker) {
-    for (const node of textNodes(root))node.data = node.data.replace(marker, '');
+function work_docx_caption_import_removeMarkerText(root, marker) {
+    for (const node of work_docx_caption_import_textNodes(root))node.data = node.data.replace(marker, '');
 }
 function removeCaptionPrefix(root, kind) {
     const label = documentCaptionLabel(kind);
@@ -146,14 +414,14 @@ function removeCaptionPrefix(root, kind) {
     const match = expression.exec(source);
     if (!match || !source.trimStart().startsWith(label) && !/^(?:Figure|Fig|Table)/i.test(source.trimStart())) return;
     let remaining = match[0].length;
-    for (const node of textNodes(root)){
+    for (const node of work_docx_caption_import_textNodes(root)){
         if (remaining <= 0) break;
         const removed = Math.min(remaining, node.data.length);
         node.data = node.data.slice(removed);
         remaining -= removed;
     }
 }
-function textNodes(root) {
+function work_docx_caption_import_textNodes(root) {
     const walker = root.ownerDocument?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
     const nodes = [];
     if (!walker) return nodes;
@@ -298,7 +566,7 @@ function markDocxCitationFields(document) {
     const citations = [];
     const bibliographies = [];
     for (const field of docxFieldOccurrences(document)){
-        if (!canMarkField(field)) continue;
+        if (!work_docx_citation_import_canMarkField(field)) continue;
         const tags = documentCitationTagsFromInstruction(field.instruction);
         if (tags.length) {
             const index = citations.length + 1;
@@ -349,7 +617,7 @@ function applyImportedDocxCitationMarkers(document, markers) {
 function hasImportedDocxCitationMarkers(markers) {
     return markers.citations.length > 0 || markers.bibliographies.length > 0;
 }
-function canMarkField(field) {
+function work_docx_citation_import_canMarkField(field) {
     return field.start !== field.end || 'fldSimple' === field.start.localName;
 }
 function work_docx_citation_import_insertFieldBoundaryMarkers(document, field, start, end) {
@@ -439,6 +707,45 @@ function work_docx_citation_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
+const TWIPS_PER_MILLIMETER = 1440 / 25.4;
+function importDocxColumns(element, fallback) {
+    const columnElements = directChildren(element, 'col');
+    const sourceCount = numberAttribute(element, 'num') || columnElements.length || fallback.count;
+    const count = Math.min(6, Math.max(1, sourceCount));
+    const spacingAttribute = attribute(element, 'space');
+    const spacing = null === spacingAttribute ? fallback.spacing : twipsToMillimeters(Number(spacingAttribute), fallback.spacing);
+    const base = {
+        count,
+        spacing,
+        separator: enabledAttribute(element, 'sep')
+    };
+    if (!columnElements.length) return normalizeDocumentColumns(base);
+    return normalizeDocumentColumns({
+        ...base,
+        count: Math.min(count, columnElements.length),
+        custom: columnElements.slice(0, count).map((column, index)=>{
+            const columnSpacing = attribute(column, 'space');
+            return {
+                widthPercent: Math.max(1, numberAttribute(column, 'w')),
+                spacing: index === Math.min(count, columnElements.length) - 1 ? 0 : null === columnSpacing ? spacing : twipsToMillimeters(Number(columnSpacing), spacing)
+            };
+        })
+    });
+}
+function numberAttribute(element, name) {
+    const value = Number(attribute(element, name));
+    return Number.isFinite(value) ? value : 0;
+}
+function enabledAttribute(element, name) {
+    const value = attribute(element, name)?.toLowerCase();
+    return '1' === value || 'true' === value || 'on' === value;
+}
+function twipsToMillimeters(value, fallback) {
+    return Number.isFinite(value) ? roundOne(Math.max(0, value) / TWIPS_PER_MILLIMETER) : fallback;
+}
+function roundOne(value) {
+    return Math.round(10 * value) / 10;
+}
 const work_docx_comment_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_comment_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 async function markDocxComments(document, archive) {
@@ -641,51 +948,12 @@ function work_docx_comment_import_compareDocumentOrder(left, right) {
     if (left === right) return 0;
     return left.compareDocumentPosition(right) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
 }
-const TWIPS_PER_MILLIMETER = 1440 / 25.4;
-function importDocxColumns(element, fallback) {
-    const columnElements = directChildren(element, 'col');
-    const sourceCount = numberAttribute(element, 'num') || columnElements.length || fallback.count;
-    const count = Math.min(6, Math.max(1, sourceCount));
-    const spacingAttribute = attribute(element, 'space');
-    const spacing = null === spacingAttribute ? fallback.spacing : twipsToMillimeters(Number(spacingAttribute), fallback.spacing);
-    const base = {
-        count,
-        spacing,
-        separator: enabledAttribute(element, 'sep')
-    };
-    if (!columnElements.length) return normalizeDocumentColumns(base);
-    return normalizeDocumentColumns({
-        ...base,
-        count: Math.min(count, columnElements.length),
-        custom: columnElements.slice(0, count).map((column, index)=>{
-            const columnSpacing = attribute(column, 'space');
-            return {
-                widthPercent: Math.max(1, numberAttribute(column, 'w')),
-                spacing: index === Math.min(count, columnElements.length) - 1 ? 0 : null === columnSpacing ? spacing : twipsToMillimeters(Number(columnSpacing), spacing)
-            };
-        })
-    });
-}
-function numberAttribute(element, name) {
-    const value = Number(attribute(element, name));
-    return Number.isFinite(value) ? value : 0;
-}
-function enabledAttribute(element, name) {
-    const value = attribute(element, name)?.toLowerCase();
-    return '1' === value || 'true' === value || 'on' === value;
-}
-function twipsToMillimeters(value, fallback) {
-    return Number.isFinite(value) ? roundOne(Math.max(0, value) / TWIPS_PER_MILLIMETER) : fallback;
-}
-function roundOne(value) {
-    return Math.round(10 * value) / 10;
-}
 const work_docx_field_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_field_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 function markDocxBodyFields(document) {
     const fields = docxFieldOccurrences(document).flatMap((field, index)=>{
         const kind = docxDocumentFieldKind(field.instruction);
-        if (!kind || !work_docx_field_import_canMarkField(field)) return [];
+        if (!kind || !docxFieldOccurrenceIsInlineEditable(field)) return [];
         const marker = {
             start: `__A3S_WORK_FIELD_START_${index + 1}__`,
             end: `__A3S_WORK_FIELD_END_${index + 1}__`,
@@ -719,9 +987,6 @@ function applyImportedDocxFieldMarkers(document, markers) {
 function hasImportedDocxFieldMarkers(markers) {
     return markers.fields.length > 0;
 }
-function work_docx_field_import_canMarkField(field) {
-    return field.start !== field.end || 'fldSimple' === field.start.localName;
-}
 function work_docx_field_import_insertFieldBoundaryMarkers(document, field, start, end) {
     if ('fldChar' === field.start.localName && 'fldChar' === field.end.localName) {
         field.start.parentNode?.insertBefore(work_docx_field_import_markerText(document, start), field.start);
@@ -769,68 +1034,262 @@ function work_docx_field_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-function extractMammothDocumentNotes(document) {
-    const definitions = extractDefinitions(document);
-    const notes = new Map();
-    const counters = {
-        footnote: 0,
-        endnote: 0
+const work_docx_image_layout_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_image_layout_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const EMUS_PER_MILLIMETER = 36000;
+const IMAGE_LAYOUT_MARKER_PATTERN = /__A3S_WORK_IMAGE_LAYOUT_\d+_(?:START|END)__/g;
+const MAX_IMPORTED_IMAGE_LAYOUTS = 4096;
+function createImportedDocxImageLayoutMarkerState() {
+    return {
+        identityRegistry: createDocumentImageIdentityRegistry(),
+        nextMarker: 1
     };
-    const references = Array.from(document.body.querySelectorAll('a[href^="#footnote-"], a[href^="#endnote-"]'));
-    for (const reference of references){
-        const target = reference.getAttribute('href')?.slice(1) ?? '';
-        const kind = noteKindFromTarget(target);
-        if (!kind) continue;
-        let note = notes.get(target);
-        if (!note) {
-            counters[kind] += 1;
-            note = {
-                id: `document-${kind}-${counters[kind]}`,
-                kind,
-                number: counters[kind],
-                html: definitions.get(target) ?? '<p></p>'
-            };
-            notes.set(target, note);
-        }
-        const marker = document.createElement('sup');
-        marker.setAttribute('data-document-note-reference', 'true');
-        marker.setAttribute('data-note-kind', note.kind);
-        marker.setAttribute('data-note-id', note.id);
-        marker.setAttribute('data-note-number', String(note.number));
-        marker.textContent = String(note.number);
-        const wrapper = reference.parentElement;
-        if (wrapper?.tagName.toLowerCase() === 'sup' && 1 === wrapper.childNodes.length) wrapper.replaceWith(marker);
-        else reference.replaceWith(marker);
-    }
-    return Array.from(notes.values());
 }
-function placeMammothDocumentNotes(document, notes) {
-    const sections = Array.from(document.body.querySelectorAll('section[data-document-section]'));
-    for (const note of notes){
-        const reference = Array.from(document.body.querySelectorAll('sup[data-document-note-reference]')).find((element)=>element.dataset.noteKind === note.kind && element.dataset.noteId === note.id);
-        const target = 'footnote' === note.kind ? reference?.closest('section[data-document-section]') : sections.at(-1);
-        (target ?? document.body).append(createDocumentNoteElement(document, note));
+function markDocxImageLayouts(document, state = createImportedDocxImageLayoutMarkerState()) {
+    const images = [];
+    const markedRuns = new Set();
+    const drawings = [
+        ...descendants(document, 'anchor'),
+        ...descendants(document, 'inline')
+    ];
+    for (const anchor of drawings){
+        const run = closestAncestor(anchor, 'r');
+        if (!run || markedRuns.has(run)) continue;
+        const crop = anchorCrop(anchor);
+        const layout = 'inline' === anchor.localName ? 'inline' : anchorLayout(anchor);
+        if (!layout) continue;
+        if (state.nextMarker > MAX_IMPORTED_IMAGE_LAYOUTS) throw new Error('Imported DOCX exceeds the image-layout limit.');
+        markedRuns.add(run);
+        const index = state.nextMarker;
+        state.nextMarker += 1;
+        const startMarker = `__A3S_WORK_IMAGE_LAYOUT_${index}_START__`;
+        const endMarker = `__A3S_WORK_IMAGE_LAYOUT_${index}_END__`;
+        insertMarkerRun(document, run, startMarker, 'before');
+        insertMarkerRun(document, run, endMarker, 'after');
+        images.push({
+            startMarker,
+            endMarker,
+            options: normalizeDocumentImageLayoutOptions({
+                layout,
+                alignment: anchorAlignment(anchor),
+                wrapDistance: anchorWrapDistance(anchor, layout),
+                wrapSide: anchorWrapSide(anchor, layout)
+            }),
+            position: anchorPosition(anchor),
+            crop,
+            contour: isContourImageLayout(layout) ? anchorWrapContour(anchor, layout) : null,
+            layer: 'anchor' === anchor.localName ? anchorLayer(anchor) : null,
+            identity: uniqueDocumentImageIdentity(drawingIdentitySource(anchor), state.identityRegistry)
+        });
     }
+    return {
+        images
+    };
 }
-function extractDefinitions(document) {
-    const definitions = new Map();
-    const elements = Array.from(document.body.querySelectorAll('li[id^="footnote-"], li[id^="endnote-"]'));
-    for (const element of elements){
-        const id = element.id;
-        const clone = element.cloneNode(true);
-        for (const backlink of Array.from(clone.querySelectorAll('a[href^="#footnote-ref-"], a[href^="#endnote-ref-"]')))backlink.remove();
-        definitions.set(id, clone.innerHTML.trim() || '<p></p>');
-        const parent = element.parentElement;
-        element.remove();
-        if (parent && !parent.children.length) parent.remove();
+function applyImportedDocxImageLayoutMarkers(document, markers) {
+    const starts = new Map(markers.images.map((image)=>[
+            image.startMarker,
+            image
+        ]));
+    const ends = new Set(markers.images.map((image)=>image.endMarker));
+    const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    const state = {
+        active: null,
+        applied: false
+    };
+    for (const node of nodes){
+        if (node instanceof Text) {
+            node.data = node.data.replace(IMAGE_LAYOUT_MARKER_PATTERN, (marker)=>{
+                const start = starts.get(marker);
+                if (start) {
+                    state.active = start;
+                    state.applied = false;
+                } else if (ends.has(marker)) {
+                    state.active = null;
+                    state.applied = false;
+                }
+                return '';
+            });
+            continue;
+        }
+        if (!state.applied && state.active && node instanceof HTMLImageElement) {
+            applyImageLayout(node, state.active.options, state.active.position, state.active.crop, state.active.contour, state.active.layer, state.active.identity);
+            state.applied = true;
+        }
     }
-    return definitions;
+    document.body.normalize();
 }
-function noteKindFromTarget(target) {
-    if (target.startsWith('footnote-')) return 'footnote';
-    if (target.startsWith('endnote-')) return 'endnote';
+function hasImportedDocxImageLayoutMarkers(markers) {
+    return markers.images.length > 0;
+}
+function anchorLayout(anchor) {
+    if (directChild(anchor, 'wrapNone')) return 'none';
+    if (directChild(anchor, 'wrapTopAndBottom')) return 'topBottom';
+    if (directChild(anchor, 'wrapSquare')) return 'square';
+    if (directChild(anchor, 'wrapTight')) return 'tight';
+    if (directChild(anchor, 'wrapThrough')) return 'through';
     return null;
 }
+function anchorAlignment(anchor) {
+    const position = directChild(anchor, 'positionH');
+    const alignment = position ? directChild(position, 'align') : void 0;
+    const value = alignment?.textContent?.trim();
+    if ('inside' === value) return 'left';
+    if ('outside' === value) return 'right';
+    return normalizeDocumentImageAlignment(value);
+}
+function anchorWrapDistance(anchor, layout) {
+    const wrap = anchorWrapElement(anchor, layout);
+    const names = 'topBottom' === layout ? [
+        'distT',
+        'distB'
+    ] : [
+        'distL',
+        'distR'
+    ];
+    const distance = Math.max(0, ...names.flatMap((name)=>[
+            numericAttribute(wrap, name) ?? 0,
+            numericAttribute(anchor, name) ?? 0
+        ]));
+    return distance / EMUS_PER_MILLIMETER;
+}
+function anchorWrapSide(anchor, layout) {
+    return normalizeDocumentImageWrapSide(attribute(anchorWrapElement(anchor, layout) ?? anchor, 'wrapText'));
+}
+function anchorWrapElement(anchor, layout) {
+    if ('square' === layout) return directChild(anchor, 'wrapSquare');
+    if ('tight' === layout) return directChild(anchor, 'wrapTight');
+    if ('through' === layout) return directChild(anchor, 'wrapThrough');
+    if ('topBottom' === layout) return directChild(anchor, 'wrapTopAndBottom');
+    if ('none' === layout) return directChild(anchor, 'wrapNone');
+}
+function anchorWrapContour(anchor, layout) {
+    const wrap = anchorWrapElement(anchor, layout);
+    const polygon = wrap ? directChild(wrap, 'wrapPolygon') : void 0;
+    if (!polygon) return null;
+    const vertices = directChildren(polygon);
+    if (vertices[0]?.localName !== 'start' || vertices.slice(1).some((element)=>'lineTo' !== element.localName)) return null;
+    return normalizeDocumentImageWrapContour({
+        edited: attribute(polygon, 'edited'),
+        points: vertices.map((point)=>({
+                x: attribute(point, 'x'),
+                y: attribute(point, 'y')
+            }))
+    });
+}
+function anchorPosition(anchor) {
+    const horizontal = directChild(anchor, 'positionH');
+    const vertical = directChild(anchor, 'positionV');
+    const horizontalOffset = positionOffset(horizontal);
+    const verticalOffset = positionOffset(vertical);
+    if (null === horizontalOffset && null === verticalOffset) return null;
+    return normalizeDocumentImagePosition({
+        horizontalOffset,
+        verticalOffset,
+        horizontalReference: horizontal ? attribute(horizontal, 'relativeFrom') : null,
+        verticalReference: vertical ? attribute(vertical, 'relativeFrom') : null
+    });
+}
+function anchorCrop(anchor) {
+    const source = descendants(anchor, 'srcRect')[0];
+    if (!source) return null;
+    return normalizeDocumentImageCrop({
+        cropTop: cropPercentage(source, 't'),
+        cropRight: cropPercentage(source, 'r'),
+        cropBottom: cropPercentage(source, 'b'),
+        cropLeft: cropPercentage(source, 'l')
+    });
+}
+function anchorLayer(anchor) {
+    return normalizeDocumentImageLayer({
+        relativeHeight: attribute(anchor, 'relativeHeight'),
+        behindDocument: anchorBooleanAttribute(anchor, 'behindDoc', false),
+        allowOverlap: anchorBooleanAttribute(anchor, 'allowOverlap', false),
+        layoutInCell: anchorBooleanAttribute(anchor, 'layoutInCell', true),
+        lockAnchor: anchorBooleanAttribute(anchor, 'locked', false)
+    });
+}
+function drawingIdentitySource(anchor) {
+    const properties = directChild(anchor, 'docPr');
+    return {
+        docPropertiesId: properties ? attribute(properties, 'id') : null,
+        anchorId: attribute(anchor, 'anchorId'),
+        editId: attribute(anchor, 'editId')
+    };
+}
+function cropPercentage(source, name) {
+    const value = attribute(source, name)?.trim() ?? '';
+    if (!value) return 0;
+    const number = Number(value.endsWith('%') ? value.slice(0, -1) : value);
+    if (!Number.isFinite(number)) return 0;
+    return value.endsWith('%') ? number : number / 1000;
+}
+function positionOffset(position) {
+    const value = position ? directChild(position, 'posOffset') : void 0;
+    if (!value?.textContent?.trim()) return null;
+    const emus = Number(value.textContent);
+    return Number.isFinite(emus) ? emus / EMUS_PER_MILLIMETER : null;
+}
+function insertMarkerRun(document, run, marker, position) {
+    const markerRun = document.createElementNS(work_docx_image_layout_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_image_layout_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_image_layout_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    markerRun.append(text);
+    const parent = run.parentNode;
+    if (!parent) return;
+    parent.insertBefore(markerRun, 'before' === position ? run : run.nextSibling);
+}
+function applyImageLayout(image, options, position, crop, contour, layer, identity) {
+    applyDocumentImageIdentityToElement(image, identity);
+    image.dataset.officeImageLayout = options.layout;
+    image.dataset.officeImageAlignment = options.alignment;
+    image.dataset.officeImageWrapDistance = formatNumber(options.wrapDistance);
+    if (wrapsBesideImage(options.layout) || 'bothSides' !== options.wrapSide) image.dataset.officeImageWrapSide = options.wrapSide;
+    else delete image.dataset.officeImageWrapSide;
+    image.style.setProperty('--work-document-image-wrap-distance', `${formatNumber(options.wrapDistance)}mm`);
+    if (position) {
+        if (null !== position.horizontalOffset) {
+            image.dataset.officeImageHorizontalOffset = formatNumber(position.horizontalOffset);
+            image.style.setProperty('--work-document-image-horizontal-offset', `${formatNumber(position.horizontalOffset)}mm`);
+        }
+        if (null !== position.verticalOffset) {
+            image.dataset.officeImageVerticalOffset = formatNumber(position.verticalOffset);
+            image.style.setProperty('--work-document-image-vertical-offset', `${formatNumber(position.verticalOffset)}mm`);
+        }
+        image.dataset.officeImageHorizontalReference = position.horizontalReference;
+        image.dataset.officeImageVerticalReference = position.verticalReference;
+    }
+    applyDocumentImageCropToElement(image, crop);
+    applyDocumentImageWrapContourToElement(image, contour);
+    if (layer) applyDocumentImageLayerToElement(image, layer);
+}
+function anchorBooleanAttribute(element, name, fallback) {
+    const value = attribute(element, name)?.trim().toLowerCase();
+    if ('1' === value || 'true' === value || 'on' === value) return true;
+    if ('0' === value || 'false' === value || 'off' === value) return false;
+    return fallback;
+}
+function numericAttribute(element, name) {
+    if (!element) return null;
+    const source = attribute(element, name);
+    if (null === source || !source.trim()) return null;
+    const value = Number(source);
+    return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function formatNumber(value) {
+    return Number(value.toFixed(2)).toString();
+}
 const work_docx_list_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_list_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const LIST_START_MARKER_PATTERN = /__A3S_WORK_LIST_START_\d+__/g;
@@ -871,14 +1330,65 @@ function markDocxLists(document, numbering) {
         const abstractId = integerAttribute(concrete ? directChild(concrete, 'abstractNumId') : null, 'val');
         const abstract = null === abstractId ? void 0 : abstractNumbering.get(abstractId);
         const start = effectiveListStart(concrete, abstract, level);
+        const definition = effectiveListLevel(concrete, abstract, level);
+        const format = stringAttribute(definition ? directChild(definition, 'numFmt') : null, 'val');
+        const text = rawStringAttribute(definition ? directChild(definition, 'lvlText') : null, 'val');
+        const suffix = stringAttribute(definition ? directChild(definition, 'suff') : null, 'val');
+        const alignment = stringAttribute(definition ? directChild(definition, 'lvlJc') : null, 'val');
+        const paragraphProperties = definition ? directChild(definition, 'pPr') : void 0;
+        const indent = paragraphProperties ? directChild(paragraphProperties, 'ind') : void 0;
+        const indentLeft = signedIntegerAttribute(indent, 'left');
+        const indentStart = signedIntegerAttribute(indent, 'start');
+        const indentRight = signedIntegerAttribute(indent, 'right');
+        const indentEnd = signedIntegerAttribute(indent, 'end');
+        const indentHanging = integerAttribute(indent, 'hanging');
+        const indentFirstLine = integerAttribute(indent, 'firstLine');
+        const restartAfterLevel = integerAttribute(definition ? directChild(definition, 'lvlRestart') : null, 'val');
         const type = effectiveOrderedListType(concrete, abstract, level);
         const bulletStyle = effectiveBulletListStyle(concrete, abstract, level);
-        if (start <= 1 && !type && !bulletStyle) continue;
         const marker = `__A3S_WORK_LIST_START_${lists.length + 1}__`;
         insertParagraphMarker(document, paragraph, marker);
         lists.push({
             marker,
             start,
+            numberingId: numId,
+            ...null === abstractId ? {} : {
+                abstractNumberingId: abstractId
+            },
+            level,
+            ...format ? {
+                format
+            } : {},
+            ...text ? {
+                text
+            } : {},
+            ...suffix ? {
+                suffix
+            } : {},
+            ...alignment ? {
+                alignment
+            } : {},
+            ...null === indentLeft ? {} : {
+                indentLeft
+            },
+            ...null === indentRight ? {} : {
+                indentRight
+            },
+            ...null === indentStart ? {} : {
+                indentStart
+            },
+            ...null === indentEnd ? {} : {
+                indentEnd
+            },
+            ...null === indentHanging ? {} : {
+                indentHanging
+            },
+            ...null === indentFirstLine ? {} : {
+                indentFirstLine
+            },
+            ...null === restartAfterLevel ? {} : {
+                restartAfterLevel
+            },
             ...type ? {
                 type
             } : {},
@@ -903,6 +1413,20 @@ function applyImportedDocxListMarkers(document, markers) {
         node.data = node.data.replace(LIST_START_MARKER_PATTERN, (marker)=>{
             const imported = listByMarker.get(marker);
             if (imported && list instanceof HTMLElement) {
+                list.dataset.officeNumberingId = String(imported.numberingId);
+                list.dataset.officeNumberingLevel = String(imported.level);
+                if (imported.format) list.dataset.officeNumberingFormat = imported.format;
+                if (imported.text) list.dataset.officeNumberingText = imported.text;
+                setOptionalDataset(list, 'officeNumberingSuffix', imported.suffix);
+                setOptionalDataset(list, 'officeNumberingAlignment', imported.alignment);
+                setOptionalDataset(list, 'officeNumberingIndentLeft', imported.indentLeft);
+                setOptionalDataset(list, 'officeNumberingIndentRight', imported.indentRight);
+                setOptionalDataset(list, 'officeNumberingIndentStart', imported.indentStart);
+                setOptionalDataset(list, 'officeNumberingIndentEnd', imported.indentEnd);
+                setOptionalDataset(list, 'officeNumberingIndentHanging', imported.indentHanging);
+                setOptionalDataset(list, 'officeNumberingIndentFirstLine', imported.indentFirstLine);
+                setOptionalDataset(list, 'officeNumberingRestartAfterLevel', imported.restartAfterLevel);
+                if (void 0 !== imported.abstractNumberingId) list.dataset.officeAbstractNumberingId = String(imported.abstractNumberingId);
                 if ('ol' === list.tagName.toLowerCase()) {
                     if (imported.start > 1) list.setAttribute('start', String(imported.start));
                     if (imported.type) list.setAttribute('type', imported.type);
@@ -967,11 +1491,25 @@ function integerAttribute(element, name) {
     const value = Number(source);
     return Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
+function signedIntegerAttribute(element, name) {
+    if (!element) return null;
+    const source = attribute(element, name) ?? (name.includes(':') ? null : attribute(element, `w:${name}`));
+    if (null === source) return null;
+    const value = Number(source);
+    return Number.isSafeInteger(value) ? value : null;
+}
+function setOptionalDataset(element, key, value) {
+    if (void 0 !== value) element.dataset[key] = String(value);
+}
 function stringAttribute(element, name) {
     if (!element) return null;
     const value = attribute(element, name) ?? (name.includes(':') ? null : attribute(element, `w:${name}`));
     return value?.trim() || null;
 }
+function rawStringAttribute(element, name) {
+    if (!element) return null;
+    return attribute(element, name) ?? (name.includes(':') ? null : attribute(element, `w:${name}`));
+}
 function work_docx_list_import_textNodes(root) {
     const document = root.ownerDocument;
     const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
@@ -980,138 +1518,107 @@ function work_docx_list_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-const work_docx_image_layout_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
-const work_docx_image_layout_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
-const EMUS_PER_MILLIMETER = 36000;
-const IMAGE_LAYOUT_MARKER_PATTERN = /__A3S_WORK_IMAGE_LAYOUT_\d+_(?:START|END)__/g;
-function markDocxImageLayouts(document) {
-    const images = [];
-    const markedRuns = new Set();
-    for (const anchor of descendants(document, 'anchor')){
-        const run = closestAncestor(anchor, 'r');
-        if (!run || markedRuns.has(run)) continue;
-        const layout = anchorLayout(anchor);
-        if (!layout) continue;
-        markedRuns.add(run);
-        const index = images.length + 1;
-        const startMarker = `__A3S_WORK_IMAGE_LAYOUT_${index}_START__`;
-        const endMarker = `__A3S_WORK_IMAGE_LAYOUT_${index}_END__`;
-        insertMarkerRun(document, run, startMarker, 'before');
-        insertMarkerRun(document, run, endMarker, 'after');
-        images.push({
-            startMarker,
-            endMarker,
-            options: normalizeDocumentImageLayoutOptions({
-                layout,
-                alignment: anchorAlignment(anchor),
-                wrapDistance: anchorWrapDistance(anchor, layout)
-            })
-        });
+async function markDocxNoteImageLayouts(archive, state) {
+    const markers = {
+        images: []
+    };
+    const parts = [];
+    for (const config of [
+        {
+            path: 'word/footnotes.xml',
+            root: 'footnotes'
+        },
+        {
+            path: 'word/endnotes.xml',
+            root: 'endnotes'
+        }
+    ]){
+        if (!archive.has(config.path)) continue;
+        const document = await archive.xml(config.path);
+        const root = document.documentElement;
+        if (root.localName !== config.root || !DOCX_WORDPROCESSING_NAMESPACES.has(root.namespaceURI ?? '')) continue;
+        const partMarkers = markDocxImageLayouts(document, state);
+        if (partMarkers.images.length) {
+            markers.images.push(...partMarkers.images);
+            parts.push({
+                document,
+                path: config.path
+            });
+        }
     }
     return {
-        images
+        markers,
+        parts
     };
 }
-function applyImportedDocxImageLayoutMarkers(document, markers) {
-    const starts = new Map(markers.images.map((image)=>[
-            image.startMarker,
-            image
-        ]));
-    const ends = new Set(markers.images.map((image)=>image.endMarker));
-    const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT);
-    const nodes = [];
-    while(walker.nextNode())nodes.push(walker.currentNode);
-    const state = {
-        active: null,
-        applied: false
+function extractMammothDocumentNotes(document) {
+    const definitions = extractDefinitions(document);
+    const notes = new Map();
+    const counters = {
+        footnote: 0,
+        endnote: 0
     };
-    for (const node of nodes){
-        if (node instanceof Text) {
-            node.data = node.data.replace(IMAGE_LAYOUT_MARKER_PATTERN, (marker)=>{
-                const start = starts.get(marker);
-                if (start) {
-                    state.active = start;
-                    state.applied = false;
-                } else if (ends.has(marker)) {
-                    state.active = null;
-                    state.applied = false;
-                }
-                return '';
-            });
-            continue;
-        }
-        if (!state.applied && state.active && node instanceof HTMLImageElement) {
-            applyImageLayout(node, state.active.options);
-            state.applied = true;
+    const references = Array.from(document.body.querySelectorAll('a[href^="#footnote-"], a[href^="#endnote-"]'));
+    for (const reference of references){
+        const target = reference.getAttribute('href')?.slice(1) ?? '';
+        const kind = noteKindFromTarget(target);
+        if (!kind) continue;
+        let note = notes.get(target);
+        if (!note) {
+            counters[kind] += 1;
+            note = {
+                id: importedDocumentNoteId(kind, target) ?? `document-${kind}-${counters[kind]}`,
+                kind,
+                number: counters[kind],
+                html: definitions.get(target) ?? '<p></p>'
+            };
+            notes.set(target, note);
         }
+        const marker = document.createElement('sup');
+        marker.setAttribute('data-document-note-reference', 'true');
+        marker.setAttribute('data-note-kind', note.kind);
+        marker.setAttribute('data-note-id', note.id);
+        marker.setAttribute('data-note-number', String(note.number));
+        marker.textContent = String(note.number);
+        const wrapper = reference.parentElement;
+        if (wrapper?.tagName.toLowerCase() === 'sup' && 1 === wrapper.childNodes.length) wrapper.replaceWith(marker);
+        else reference.replaceWith(marker);
     }
-    document.body.normalize();
-}
-function hasImportedDocxImageLayoutMarkers(markers) {
-    return markers.images.length > 0;
-}
-function anchorLayout(anchor) {
-    if (directChild(anchor, 'wrapTopAndBottom')) return 'topBottom';
-    if (directChild(anchor, 'wrapSquare') || directChild(anchor, 'wrapTight') || directChild(anchor, 'wrapThrough')) return 'square';
-    return null;
-}
-function anchorAlignment(anchor) {
-    const position = directChild(anchor, 'positionH');
-    const alignment = position ? directChild(position, 'align') : void 0;
-    const value = alignment?.textContent?.trim();
-    if ('inside' === value) return 'left';
-    if ('outside' === value) return 'right';
-    return normalizeDocumentImageAlignment(value);
-}
-function anchorWrapDistance(anchor, layout) {
-    const wrap = directChild(anchor, 'square' === layout ? 'wrapSquare' : 'wrapTopAndBottom') ?? ('square' === layout ? directChild(anchor, 'wrapTight') ?? directChild(anchor, 'wrapThrough') : void 0);
-    const names = 'square' === layout ? [
-        'distL',
-        'distR'
-    ] : [
-        'distT',
-        'distB'
-    ];
-    const distance = Math.max(0, ...names.flatMap((name)=>[
-            numericAttribute(wrap, name) ?? 0,
-            numericAttribute(anchor, name) ?? 0
-        ]));
-    return distance / EMUS_PER_MILLIMETER;
-}
-function insertMarkerRun(document, run, marker, position) {
-    const markerRun = document.createElementNS(work_docx_image_layout_import_WORD_NAMESPACE, 'w:r');
-    const text = document.createElementNS(work_docx_image_layout_import_WORD_NAMESPACE, 'w:t');
-    text.setAttributeNS(work_docx_image_layout_import_XML_NAMESPACE, 'xml:space', 'preserve');
-    text.textContent = marker;
-    markerRun.append(text);
-    const parent = run.parentNode;
-    if (!parent) return;
-    parent.insertBefore(markerRun, 'before' === position ? run : run.nextSibling);
-}
-function applyImageLayout(image, options) {
-    image.dataset.officeImageLayout = options.layout;
-    image.dataset.officeImageAlignment = options.alignment;
-    image.dataset.officeImageWrapDistance = formatNumber(options.wrapDistance);
-    image.style.setProperty('--work-document-image-wrap-distance', `${formatNumber(options.wrapDistance)}mm`);
+    return Array.from(notes.values());
 }
-function numericAttribute(element, name) {
-    if (!element) return null;
-    const source = attribute(element, name);
-    if (null === source || !source.trim()) return null;
-    const value = Number(source);
-    return Number.isFinite(value) && value >= 0 ? value : null;
+function placeMammothDocumentNotes(document, notes) {
+    const sections = Array.from(document.body.querySelectorAll('section[data-document-section]'));
+    for (const note of notes){
+        const reference = Array.from(document.body.querySelectorAll('sup[data-document-note-reference]')).find((element)=>element.dataset.noteKind === note.kind && element.dataset.noteId === note.id);
+        const target = 'footnote' === note.kind ? reference?.closest('section[data-document-section]') : sections.at(-1);
+        (target ?? document.body).append(createDocumentNoteElement(document, note));
+    }
 }
-function closestAncestor(element, localName) {
-    let current = element;
-    while(current){
-        if (current.localName === localName) return current;
-        current = current.parentElement;
+function extractDefinitions(document) {
+    const definitions = new Map();
+    const elements = Array.from(document.body.querySelectorAll('li[id^="footnote-"], li[id^="endnote-"]'));
+    for (const element of elements){
+        const id = element.id;
+        const clone = element.cloneNode(true);
+        for (const backlink of Array.from(clone.querySelectorAll('a[href^="#footnote-ref-"], a[href^="#endnote-ref-"]')))backlink.remove();
+        definitions.set(id, clone.innerHTML.trim() || '<p></p>');
+        const parent = element.parentElement;
+        element.remove();
+        if (parent && !parent.children.length) parent.remove();
     }
-    return null;
+    return definitions;
 }
-function formatNumber(value) {
-    return Number(value.toFixed(2)).toString();
+function noteKindFromTarget(target) {
+    if (target.startsWith('footnote-')) return 'footnote';
+    if (target.startsWith('endnote-')) return 'endnote';
+    return null;
 }
+const WORDPROCESSING_DRAWING_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
+    'http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing'
+]);
+const WORDPROCESSING_DRAWING_2010_NAMESPACE = 'http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing';
+const WORD_2010_NAMESPACE = 'http://schemas.microsoft.com/office/word/2010/wordml';
 async function importSectionPageChrome(section, archive, documentRelationships, previous, oddEvenEnabled) {
     const fallback = normalizeDocumentPageChrome(previous.pageChrome, previous);
     const variants = await Promise.all([
@@ -1162,16 +1669,25 @@ async function importReferencedPart(section, referenceName, variant, archive, do
 }
 async function pageChromePartHtml(document, archive, partPath) {
     const relationships = await archive.relationships(partPath);
+    const themePath = archive.paths('word/theme/').find((path)=>/\/theme\d*\.xml$/i.test(path));
+    const themeDocument = themePath ? await archive.xml(themePath) : null;
+    const settingsDocument = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
+    const stylesDocument = archive.has('word/styles.xml') ? await archive.xml('word/styles.xml') : null;
+    const theme = createDocxThemeResolver(themeDocument, settingsDocument);
+    const paragraphStyles = createDocxParagraphStyleResolver(stylesDocument);
+    const tableStyles = createDocxTableStyleResolver(stylesDocument);
     const root = document.documentElement;
     const blocks = [];
     for (const child of directChildren(root)){
-        if ('p' === child.localName) blocks.push(await paragraphHtml(child, archive, relationships));
-        if ('tbl' === child.localName) blocks.push(await tableHtml(child, archive, relationships));
+        if ('p' === child.localName) blocks.push(await paragraphHtml(child, archive, relationships, theme, paragraphStyles, tableStyles));
+        if ('tbl' === child.localName) blocks.push(await tableHtml(child, archive, relationships, theme, paragraphStyles, tableStyles));
+        if (isDocxEquationLikeRoot(child)) blocks.push(`<p>${docxEquationHtml(child)}</p>`);
     }
     return blocks.join('');
 }
-async function paragraphHtml(paragraph, archive, relationships) {
-    const alignmentValue = attribute(firstDescendant(directChild(paragraph, 'pPr'), 'jc') ?? paragraph, 'val');
+async function paragraphHtml(paragraph, archive, relationships, theme, paragraphStyles, tableStyles) {
+    const properties = directChild(paragraph, 'pPr');
+    const alignmentValue = attribute(firstDescendant(properties, 'jc') ?? paragraph, 'val');
     const alignment = 'center' === alignmentValue ? 'center' : 'right' === alignmentValue || 'end' === alignmentValue ? 'right' : 'both' === alignmentValue || 'distribute' === alignmentValue ? 'justify' : 'left' === alignmentValue || 'start' === alignmentValue ? 'left' : '';
     const field = {
         active: false,
@@ -1181,6 +1697,10 @@ async function paragraphHtml(paragraph, archive, relationships) {
     };
     let html = '';
     for (const child of directChildren(paragraph))if ('pPr' !== child.localName) {
+        if (isDocxEquationLikeRoot(child)) {
+            html += docxEquationHtml(child);
+            continue;
+        }
         if ('hyperlink' === child.localName) {
             const content = await containerRunsHtml(child, field, archive, relationships);
             const relationship = relationships.get(attribute(child, 'r:id') ?? '');
@@ -1196,12 +1716,44 @@ async function paragraphHtml(paragraph, archive, relationships) {
         }
         html += await containerRunsHtml(child, field, archive, relationships);
     }
-    return `<p${alignment ? ` style="text-align: ${alignment}"` : ''}>${html}</p>`;
+    const identityAttributes = paragraphIdentityAttributes(paragraph);
+    const defaultCollapsed = properties ? parseDocxParagraphDefaultCollapsed(properties) : {
+        status: 'absent'
+    };
+    const defaultCollapsedAttribute = 'valid' === defaultCollapsed.status ? ` data-office-default-collapsed="${defaultCollapsed.value}"` : '';
+    const parsedShading = properties ? parseDirectDocxParagraphShading(properties, theme) : void 0;
+    const shading = null === parsedShading ? {
+        pattern: 'nil'
+    } : parsedShading;
+    const shadingAttributes = documentParagraphShadingDomAttributes(shading);
+    const borders = resolveDocxParagraphBordersForParagraph(paragraph, paragraphStyles, theme, tableStyles).borders;
+    const borderAttributes = documentParagraphBordersDomAttributes(borders);
+    const styles = [
+        alignment ? `text-align: ${alignment}` : '',
+        borderAttributes.style ?? '',
+        shadingAttributes.style ?? ''
+    ].filter(Boolean);
+    const borderAttribute = borderAttributes['data-office-paragraph-borders'];
+    const shadingAttribute = shadingAttributes['data-office-paragraph-shading'];
+    return `<p${styles.length ? ` style="${escapeHtml(styles.join('; '))}"` : ''}${identityAttributes}${defaultCollapsedAttribute}${borderAttribute ? ` data-office-paragraph-borders="${escapeHtml(borderAttribute)}"` : ''}${shadingAttribute ? ` data-office-paragraph-shading="${escapeHtml(shadingAttribute)}"` : ''}>${html}</p>`;
+}
+function paragraphIdentityAttributes(paragraph) {
+    const identity = normalizeDocumentParagraphIdentity({
+        paragraphId: namespacedAttribute(paragraph, WORD_2010_NAMESPACE, 'paraId'),
+        textId: namespacedAttribute(paragraph, WORD_2010_NAMESPACE, 'textId')
+    });
+    return identity ? ` data-office-paragraph-id="${identity.paragraphId}" data-office-paragraph-text-id="${identity.textId}"` : '';
 }
 async function containerRunsHtml(container, field, archive, relationships) {
     if ('r' === container.localName) return runHtml(container, field, archive, relationships);
     let html = '';
-    for (const run of descendants(container, 'r'))html += await runHtml(run, field, archive, relationships);
+    for (const child of directChildren(container)){
+        if (isDocxEquationLikeRoot(child)) {
+            html += docxEquationHtml(child);
+            continue;
+        }
+        html += await containerRunsHtml(child, field, archive, relationships);
+    }
     return html;
 }
 async function runHtml(run, field, archive, relationships) {
@@ -1216,6 +1768,10 @@ async function runHtml(run, field, archive, relationships) {
             continue;
         }
         if (fieldContentVisible(field)) {
+            if (isDocxEquationLikeRoot(child)) {
+                content += docxEquationHtml(child);
+                continue;
+            }
             if ('t' === child.localName) content += escapeHtml(child.textContent ?? '');
             if ('tab' === child.localName) content += '&#9;';
             if ('br' === child.localName || 'cr' === child.localName) content += '<br>';
@@ -1243,20 +1799,48 @@ async function drawingHtml(drawing, archive, relationships) {
     const extent = firstDescendant(drawing, 'extent');
     const width = Math.max(1, Math.round(Number(attribute(extent ?? drawing, 'cx')) / 9525));
     const height = Math.max(1, Math.round(Number(attribute(extent ?? drawing, 'cy')) / 9525));
-    return `<img src="${source}" alt="Header or footer image"${width > 1 ? ` width="${width}"` : ''}${height > 1 ? ` height="${height}"` : ''}>`;
+    const identityAttributes = drawingIdentityAttributes(drawing);
+    return `<img src="${source}" alt="Header or footer image"${width > 1 ? ` width="${width}"` : ''}${height > 1 ? ` height="${height}"` : ''}${identityAttributes}>`;
+}
+function drawingIdentityAttributes(drawing) {
+    const anchor = Array.from(drawing.querySelectorAll('*')).find((element)=>('anchor' === element.localName || 'inline' === element.localName) && WORDPROCESSING_DRAWING_NAMESPACES.has(element.namespaceURI ?? ''));
+    const properties = anchor ? directChildren(anchor, 'docPr').find((element)=>WORDPROCESSING_DRAWING_NAMESPACES.has(element.namespaceURI ?? '')) : void 0;
+    const identity = normalizeDocumentImageIdentity({
+        docPropertiesId: properties?.getAttribute('id'),
+        anchorId: anchor ? namespacedAttribute(anchor, WORDPROCESSING_DRAWING_2010_NAMESPACE, 'anchorId') : null,
+        editId: anchor ? namespacedAttribute(anchor, WORDPROCESSING_DRAWING_2010_NAMESPACE, 'editId') : null
+    });
+    if (!identity) return '';
+    return [
+        ` data-office-image-object-id="${identity.objectId}"`,
+        ` data-office-image-doc-properties-id="${identity.docPropertiesId}"`,
+        ` data-office-image-anchor-id="${identity.anchorId}"`,
+        ` data-office-image-edit-id="${identity.editId}"`
+    ].join('');
+}
+function namespacedAttribute(element, namespace, localName) {
+    for (const item of Array.from(element.attributes))if (xmlAttributeLocalName(item) === localName && xmlAttributeNamespace(element, item) === namespace) return item.value;
+    return null;
 }
-async function tableHtml(table, archive, relationships) {
+async function tableHtml(table, archive, relationships, theme, paragraphStyles, tableStyles) {
     const rows = [];
     for (const row of directChildren(table, 'tr')){
         const cells = [];
         for (const cell of directChildren(row, 'tc')){
-            const paragraphs = await Promise.all(directChildren(cell, 'p').map((item)=>paragraphHtml(item, archive, relationships)));
+            const paragraphs = await Promise.all(directChildren(cell, 'p').map((item)=>paragraphHtml(item, archive, relationships, theme, paragraphStyles, tableStyles)));
             cells.push(`<td>${paragraphs.join('')}</td>`);
         }
-        rows.push(`<tr>${cells.join('')}</tr>`);
+        rows.push(`<tr${tableRowIdentityAttributes(row)}>${cells.join('')}</tr>`);
     }
     return `<table><tbody>${rows.join('')}</tbody></table>`;
 }
+function tableRowIdentityAttributes(row) {
+    const identity = normalizeDocumentTableRowIdentity({
+        rowId: namespacedAttribute(row, WORD_2010_NAMESPACE, 'paraId'),
+        rowTextId: namespacedAttribute(row, WORD_2010_NAMESPACE, 'textId')
+    });
+    return identity ? ` ${DOCUMENT_TABLE_ROW_ID_ATTRIBUTE}="${identity.rowId}" ${DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE}="${identity.rowTextId}"` : '';
+}
 function containsPageNumber(document) {
     return descendants(document, 'instrText').some((element)=>/\bPAGE\b/i.test(element.textContent ?? '')) || descendants(document, 'fldSimple').some((element)=>/\bPAGE\b/i.test(attribute(element, 'instr') ?? ''));
 }
@@ -1297,339 +1881,135 @@ function updateFieldState(field, fieldType) {
 function fieldContentVisible(field) {
     return !field.active || field.separated && !field.skipResult;
 }
-const MAX_STYLE_INHERITANCE_DEPTH = 64;
-function createDocxParagraphStyleResolver(stylesDocument) {
-    if (!stylesDocument) return {
-        styles: new Map(),
-        characterStyles: new Map()
-    };
-    const styles = new Map();
-    const characterStyles = new Map();
-    let defaultStyleId;
-    for (const style of descendants(stylesDocument, 'style')){
-        const type = wordAttribute(style, 'type');
-        if ('paragraph' !== type && 'character' !== type) continue;
-        const styleId = wordAttribute(style, 'styleId')?.trim();
-        if (!styleId) continue;
-        const basedOn = directChild(style, 'basedOn');
-        const value = {
-            basedOn: basedOn ? wordAttribute(basedOn, 'val')?.trim() || void 0 : void 0,
-            paragraphProperties: directChild(style, 'pPr'),
-            runProperties: directChild(style, 'rPr')
-        };
-        if ('paragraph' === type) styles.set(styleId, value);
-        else characterStyles.set(styleId, value);
-        if ('paragraph' === type && !defaultStyleId && onOffAttribute(style, 'default')) defaultStyleId = styleId;
-    }
-    return {
-        defaultProperties: childPath(stylesDocument.documentElement, 'docDefaults', 'pPrDefault', 'pPr'),
-        defaultRunProperties: childPath(stylesDocument.documentElement, 'docDefaults', 'rPrDefault', 'rPr'),
-        defaultStyleId,
-        styles,
-        characterStyles
-    };
-}
-function resolveDocxParagraphStyleResolver(source) {
-    return source && 'styles' in source ? source : createDocxParagraphStyleResolver(source);
-}
-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, 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;
-    const characterStyleId = characterStyleReference ? wordAttribute(characterStyleReference, 'val')?.trim() : void 0;
-    if (characterStyleId) sources.push(...stylePropertySources(resolver.characterStyles, characterStyleId, 'runProperties'));
-    if (runProperties) sources.push(runProperties);
-    return sources;
-}
-function stylePropertySources(styles, styleId, property) {
-    const inherited = [];
-    const visited = new Set();
-    let currentStyleId = styleId;
-    let depth = 0;
-    while(currentStyleId && depth < MAX_STYLE_INHERITANCE_DEPTH && !visited.has(currentStyleId)){
-        depth += 1;
-        visited.add(currentStyleId);
-        const style = styles.get(currentStyleId);
-        if (!style) break;
-        const properties = style[property];
-        if (properties) inherited.push(properties);
-        currentStyleId = style.basedOn;
-    }
-    return inherited.reverse();
-}
-function onOffAttribute(element, name) {
-    const value = wordAttribute(element, name)?.trim().toLowerCase();
-    if (null == value) return false;
-    return '0' !== value && 'false' !== value && 'off' !== value;
-}
-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
+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, 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, docxTableParagraphPropertySources(paragraph, tableStyles));
+        const alignment = paragraphAlignment(sources);
+        if (!alignment) continue;
+        properties ??= insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_ALIGNMENT_${paragraphs.length + 1}__`;
+        work_docx_paragraph_alignment_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            alignment
         });
-        if (!defaultStyleId && work_docx_table_styles_onOffAttribute(style, 'default')) defaultStyleId = styleId;
     }
     return {
-        defaultStyleId,
-        tableStyles
+        paragraphs
     };
 }
-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 applyImportedDocxParagraphAlignmentMarkers(document, markers) {
+    const alignmentByMarker = new Map(markers.paragraphs.map(({ marker, alignment })=>[
+            marker,
+            alignment
+        ]));
+    for (const node of work_docx_paragraph_alignment_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_PARAGRAPH_ALIGNMENT_')) node.data = node.data.replace(PARAGRAPH_ALIGNMENT_MARKER_PATTERN, (marker)=>{
+        const alignment = alignmentByMarker.get(marker);
+        const block = alignment ? closestParagraphBlock(node.parentElement, node) : null;
+        if (block && alignment) block.style.textAlign = alignment;
+        return '';
+    });
+    document.body.normalize();
 }
-function styleLayerFromStyle(style) {
-    return {
-        tableProperties: style.tableProperties,
-        cellProperties: style.cellProperties,
-        paragraphProperties: style.paragraphProperties,
-        runProperties: style.runProperties
-    };
+function hasImportedDocxParagraphAlignmentMarkers(markers) {
+    return markers.paragraphs.length > 0;
 }
-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
-    };
+function paragraphAlignment(propertySources) {
+    let direction = 'ltr';
+    let justification = null;
+    let hasJustification = false;
     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);
+        const bidi = directChild(properties, 'bidi');
+        if (bidi) direction = onOffValue(bidi) ? 'rtl' : 'ltr';
+        const source = directChild(properties, 'jc');
+        if (source) {
+            hasJustification = true;
+            justification = wordAttribute(source, 'val')?.trim() ?? null;
         }
-        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;
+    if (!hasJustification || !justification) return null;
+    if ('center' === justification) return 'center';
+    if ('left' === justification) return 'left';
+    if ('right' === justification) return 'right';
+    if ('start' === justification) return 'rtl' === direction ? 'right' : 'left';
+    if ('end' === justification) return 'rtl' === direction ? 'left' : 'right';
+    if ('both' === justification || 'distribute' === justification || 'highKashida' === justification || 'lowKashida' === justification || 'mediumKashida' === justification || 'thaiDistribute' === justification) return 'justify';
+    return null;
 }
-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 onOffValue(element) {
+    const value = wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
 }
-function rowCells(row) {
-    return descendants(row, 'tc').filter((cell)=>work_docx_table_styles_closestAncestor(cell, 'tr') === row);
+function wordAttribute(element, name) {
+    return attribute(element, name) ?? attribute(element, `w:${name}`);
 }
-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 work_docx_paragraph_alignment_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_alignment_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
 }
-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 insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
 }
-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 closestParagraphBlock(element, markerNode) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
+    if (!(block instanceof HTMLElement)) return null;
+    return 'li' === block.tagName.toLowerCase() ? wrapListItemParagraph(block, markerNode) : block;
 }
-function work_docx_table_styles_onOffAttribute(element, name) {
-    return onOffValue(work_docx_table_styles_wordAttribute(element, name)) ?? false;
+function wrapListItemParagraph(item, markerNode) {
+    let anchor = markerNode;
+    while(anchor.parentNode && anchor.parentNode !== item)anchor = anchor.parentNode;
+    const children = Array.from(item.childNodes);
+    const anchorIndex = children.indexOf(anchor);
+    if (anchorIndex < 0) return item;
+    let start = anchorIndex;
+    let end = anchorIndex;
+    while(start > 0 && !isListItemBlock(children[start - 1]))start -= 1;
+    while(end + 1 < children.length && !isListItemBlock(children[end + 1]))end += 1;
+    const paragraph = item.ownerDocument.createElement('p');
+    const grouped = children.slice(start, end + 1);
+    item.insertBefore(paragraph, grouped[0] ?? null);
+    paragraph.append(...grouped);
+    return paragraph;
 }
-function onOffValue(value) {
-    if (null == value) return;
-    const normalized = value.trim().toLowerCase();
-    return '0' !== normalized && 'false' !== normalized && 'off' !== normalized;
+function isListItemBlock(node) {
+    if (!(node instanceof HTMLElement)) return false;
+    return [
+        'blockquote',
+        'div',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'hr',
+        'ol',
+        'p',
+        'pre',
+        'table',
+        'ul'
+    ].includes(node.tagName.toLowerCase());
 }
-function work_docx_table_styles_wordAttribute(element, name) {
-    return attribute(element, name) ?? attribute(element, `w:${name}`);
+function work_docx_paragraph_alignment_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
 }
 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';
@@ -1643,7 +2023,7 @@ function markDocxParagraphDirections(document, styleSource, tableStyleSource) {
         const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
         const direction = paragraphDirection(sources);
         if (!direction) continue;
-        properties ??= insertParagraphProperties(document, paragraph);
+        properties ??= work_docx_paragraph_direction_import_insertParagraphProperties(document, paragraph);
         const marker = `__A3S_WORK_PARAGRAPH_DIRECTION_${paragraphs.length + 1}__`;
         work_docx_paragraph_direction_import_insertParagraphMarker(document, paragraph, properties, marker);
         paragraphs.push({
@@ -1662,7 +2042,7 @@ function applyImportedDocxParagraphDirectionMarkers(document, markers) {
         ]));
     for (const node of work_docx_paragraph_direction_import_textNodes(document.body)){
         if (!node.data.includes('__A3S_WORK_PARAGRAPH_DIRECTION_')) continue;
-        const block = closestParagraphBlock(node.parentElement);
+        const block = work_docx_paragraph_direction_import_closestParagraphBlock(node.parentElement);
         node.data = node.data.replace(PARAGRAPH_DIRECTION_MARKER_PATTERN, (marker)=>{
             const direction = directionByMarker.get(marker);
             if (block && direction) block.setAttribute('dir', direction);
@@ -1694,12 +2074,12 @@ function work_docx_paragraph_direction_import_insertParagraphMarker(document, pa
     run.append(text);
     paragraph.insertBefore(run, properties.nextSibling);
 }
-function insertParagraphProperties(document, paragraph) {
+function work_docx_paragraph_direction_import_insertParagraphProperties(document, paragraph) {
     const properties = document.createElementNS(work_docx_paragraph_direction_import_WORD_NAMESPACE, 'w:pPr');
     paragraph.insertBefore(properties, paragraph.firstChild);
     return properties;
 }
-function closestParagraphBlock(element) {
+function work_docx_paragraph_direction_import_closestParagraphBlock(element) {
     const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
     return block instanceof HTMLElement ? block : null;
 }
@@ -1711,114 +2091,117 @@ function work_docx_paragraph_direction_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-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, tableStyleSource) {
+const work_docx_paragraph_identity_import_WORD_2010_NAMESPACE = 'http://schemas.microsoft.com/office/word/2010/wordml';
+const work_docx_paragraph_identity_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_IDENTITY_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_IDENTITY_\d+__/g;
+const MAX_PARAGRAPH_IDENTITIES = 65536;
+function markDocxParagraphIdentities(document) {
+    const counts = wordIdentityIdCounts(document);
+    const candidates = descendants(document, 'p').flatMap((element)=>{
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '')) return [];
+        const identity = wordParagraphIdentity(element);
+        return identity ? [
+            {
+                element,
+                identity
+            }
+        ] : [];
+    });
+    if (candidates.length > MAX_PARAGRAPH_IDENTITIES) throw new Error('DOCX exceeds the paragraph-identity limit.');
     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, docxTableParagraphPropertySources(paragraph, tableStyles));
-        const alignment = paragraphAlignment(sources);
-        if (!alignment) continue;
-        properties ??= work_docx_paragraph_alignment_import_insertParagraphProperties(document, paragraph);
-        const marker = `__A3S_WORK_PARAGRAPH_ALIGNMENT_${paragraphs.length + 1}__`;
-        work_docx_paragraph_alignment_import_insertParagraphMarker(document, paragraph, properties, marker);
+    for (const candidate of candidates){
+        if (1 !== counts.get(candidate.identity.paragraphId)) continue;
+        const marker = `__A3S_WORK_PARAGRAPH_IDENTITY_${paragraphs.length + 1}__`;
+        work_docx_paragraph_identity_import_insertParagraphMarker(candidate.element, marker);
         paragraphs.push({
             marker,
-            alignment
+            ...candidate.identity
         });
     }
     return {
         paragraphs
     };
 }
-function applyImportedDocxParagraphAlignmentMarkers(document, markers) {
-    const alignmentByMarker = new Map(markers.paragraphs.map(({ marker, alignment })=>[
+function wordIdentityIdCounts(document) {
+    const counts = new Map();
+    for (const localName of [
+        'p',
+        'tr'
+    ])for (const element of descendants(document, localName)){
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '')) continue;
+        const paragraphId = normalizeDocumentParagraphId(word2010Attribute(element, 'paraId'));
+        if (paragraphId) counts.set(paragraphId, (counts.get(paragraphId) ?? 0) + 1);
+    }
+    return counts;
+}
+function applyImportedDocxParagraphIdentityMarkers(document, markers) {
+    const identities = new Map(markers.paragraphs.map(({ marker, paragraphId, textId })=>[
             marker,
-            alignment
+            {
+                paragraphId,
+                textId
+            }
         ]));
-    for (const node of work_docx_paragraph_alignment_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_PARAGRAPH_ALIGNMENT_')) node.data = node.data.replace(PARAGRAPH_ALIGNMENT_MARKER_PATTERN, (marker)=>{
-        const alignment = alignmentByMarker.get(marker);
-        const block = alignment ? work_docx_paragraph_alignment_import_closestParagraphBlock(node.parentElement, node) : null;
-        if (block && alignment) block.style.textAlign = alignment;
+    for (const node of work_docx_paragraph_identity_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_PARAGRAPH_IDENTITY_')) node.data = node.data.replace(PARAGRAPH_IDENTITY_MARKER_PATTERN, (marker)=>{
+        const identity = identities.get(marker);
+        const block = identity ? work_docx_paragraph_identity_import_closestParagraphBlock(node.parentElement, node) : null;
+        if (identity && block) applyDocumentParagraphIdentityToElement(block, identity);
         return '';
     });
     document.body.normalize();
 }
-function hasImportedDocxParagraphAlignmentMarkers(markers) {
+function hasImportedDocxParagraphIdentityMarkers(markers) {
     return markers.paragraphs.length > 0;
 }
-function paragraphAlignment(propertySources) {
-    let direction = 'ltr';
-    let justification = null;
-    let hasJustification = false;
-    for (const properties of propertySources){
-        const bidi = directChild(properties, 'bidi');
-        if (bidi) direction = work_docx_paragraph_alignment_import_onOffValue(bidi) ? 'rtl' : 'ltr';
-        const source = directChild(properties, 'jc');
-        if (source) {
-            hasJustification = true;
-            justification = work_docx_paragraph_alignment_import_wordAttribute(source, 'val')?.trim() ?? null;
-        }
-    }
-    if (!hasJustification || !justification) return null;
-    if ('center' === justification) return 'center';
-    if ('left' === justification) return 'left';
-    if ('right' === justification) return 'right';
-    if ('start' === justification) return 'rtl' === direction ? 'right' : 'left';
-    if ('end' === justification) return 'rtl' === direction ? 'left' : 'right';
-    if ('both' === justification || 'distribute' === justification || 'highKashida' === justification || 'lowKashida' === justification || 'mediumKashida' === justification || 'thaiDistribute' === justification) return 'justify';
-    return null;
-}
-function work_docx_paragraph_alignment_import_onOffValue(element) {
-    const value = work_docx_paragraph_alignment_import_wordAttribute(element, 'val')?.trim().toLowerCase();
-    return '0' !== value && 'false' !== value && 'off' !== value;
+function wordParagraphIdentity(paragraph) {
+    return normalizeDocumentParagraphIdentity({
+        paragraphId: word2010Attribute(paragraph, 'paraId'),
+        textId: word2010Attribute(paragraph, 'textId')
+    });
 }
-function work_docx_paragraph_alignment_import_wordAttribute(element, name) {
-    return attribute(element, name) ?? attribute(element, `w:${name}`);
+function word2010Attribute(element, localName) {
+    return Array.from(element.attributes).find((item)=>xmlAttributeLocalName(item) === localName && xmlAttributeNamespace(element, item) === work_docx_paragraph_identity_import_WORD_2010_NAMESPACE)?.value ?? null;
 }
-function work_docx_paragraph_alignment_import_insertParagraphMarker(document, paragraph, properties, marker) {
-    const run = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:r');
-    const text = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:t');
-    text.setAttributeNS(work_docx_paragraph_alignment_import_XML_NAMESPACE, 'xml:space', 'preserve');
+function work_docx_paragraph_identity_import_insertParagraphMarker(paragraph, marker) {
+    const document = paragraph.ownerDocument;
+    const namespace = paragraph.namespaceURI ?? '';
+    const prefix = paragraph.prefix ? `${paragraph.prefix}:` : '';
+    const run = document.createElementNS(namespace, `${prefix}r`);
+    const text = document.createElementNS(namespace, `${prefix}t`);
+    text.setAttributeNS(work_docx_paragraph_identity_import_XML_NAMESPACE, 'xml:space', 'preserve');
     text.textContent = marker;
     run.append(text);
-    paragraph.insertBefore(run, properties.nextSibling);
-}
-function work_docx_paragraph_alignment_import_insertParagraphProperties(document, paragraph) {
-    const properties = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:pPr');
-    paragraph.insertBefore(properties, paragraph.firstChild);
-    return properties;
+    const properties = directChildren(paragraph, 'pPr').find((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? ''));
+    paragraph.insertBefore(run, properties?.nextSibling ?? paragraph.firstChild);
 }
-function work_docx_paragraph_alignment_import_closestParagraphBlock(element, markerNode) {
-    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
-    if (!(block instanceof HTMLElement)) return null;
-    return 'li' === block.tagName.toLowerCase() ? wrapListItemParagraph(block, markerNode) : block;
+function work_docx_paragraph_identity_import_closestParagraphBlock(element, markerNode) {
+    const explicit = element?.closest('p, h1, h2, h3, h4, h5, h6, figcaption');
+    if (explicit instanceof HTMLElement) return explicit;
+    const container = element?.closest('li, blockquote, td, th, div');
+    return container instanceof HTMLElement ? wrapParagraphSegment(container, markerNode) : null;
 }
-function wrapListItemParagraph(item, markerNode) {
+function wrapParagraphSegment(container, markerNode) {
     let anchor = markerNode;
-    while(anchor.parentNode && anchor.parentNode !== item)anchor = anchor.parentNode;
-    const children = Array.from(item.childNodes);
+    while(anchor.parentNode && anchor.parentNode !== container)anchor = anchor.parentNode;
+    const children = Array.from(container.childNodes);
     const anchorIndex = children.indexOf(anchor);
-    if (anchorIndex < 0) return item;
+    if (anchorIndex < 0) return container;
     let start = anchorIndex;
     let end = anchorIndex;
-    while(start > 0 && !isListItemBlock(children[start - 1]))start -= 1;
-    while(end + 1 < children.length && !isListItemBlock(children[end + 1]))end += 1;
-    const paragraph = item.ownerDocument.createElement('p');
+    while(start > 0 && !isParagraphBoundary(children[start - 1]))start -= 1;
+    while(end + 1 < children.length && !isParagraphBoundary(children[end + 1]))end += 1;
+    const paragraph = container.ownerDocument.createElement('p');
     const grouped = children.slice(start, end + 1);
-    item.insertBefore(paragraph, grouped[0] ?? null);
+    container.insertBefore(paragraph, grouped[0] ?? null);
     paragraph.append(...grouped);
     return paragraph;
 }
-function isListItemBlock(node) {
+function isParagraphBoundary(node) {
     if (!(node instanceof HTMLElement)) return false;
     return [
         'blockquote',
         'div',
+        'figcaption',
         'h1',
         'h2',
         'h3',
@@ -1833,9 +2216,8 @@ function isListItemBlock(node) {
         'ul'
     ].includes(node.tagName.toLowerCase());
 }
-function work_docx_paragraph_alignment_import_textNodes(root) {
-    const document = root.ownerDocument;
-    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+function work_docx_paragraph_identity_import_textNodes(root) {
+    const walker = root.ownerDocument?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
     const nodes = [];
     if (!walker) return nodes;
     while(walker.nextNode())nodes.push(walker.currentNode);
@@ -2011,10 +2393,18 @@ function paragraphPagination(sources) {
         const keepWithNext = directChild(properties, 'keepNext');
         const pageBreakBefore = directChild(properties, 'pageBreakBefore');
         const widowControl = directChild(properties, 'widowControl');
+        const contextualSpacing = directChild(properties, 'contextualSpacing');
+        const outlineLevel = directChild(properties, 'outlineLvl');
+        const defaultCollapsed = parseDocxParagraphDefaultCollapsed(properties);
         if (keepLines) pagination.keepLines = work_docx_paragraph_pagination_import_onOffValue(keepLines);
         if (keepWithNext) pagination.keepWithNext = work_docx_paragraph_pagination_import_onOffValue(keepWithNext);
         if (pageBreakBefore) pagination.pageBreakBefore = work_docx_paragraph_pagination_import_onOffValue(pageBreakBefore);
         if (widowControl) pagination.widowControl = work_docx_paragraph_pagination_import_onOffValue(widowControl);
+        if (contextualSpacing) pagination.contextualSpacing = work_docx_paragraph_pagination_import_onOffValue(contextualSpacing);
+        const outline = integerValue(outlineLevel);
+        if (null !== outline && outline <= 9) pagination.outlineLevel = outline;
+        if ('valid' === defaultCollapsed.status) pagination.defaultCollapsed = defaultCollapsed.value;
+        else if ('invalid' === defaultCollapsed.status) delete pagination.defaultCollapsed;
     }
     return pagination;
 }
@@ -2044,6 +2434,14 @@ function applyParagraphPagination(element, pagination) {
     setBooleanAttribute(element, 'data-office-keep-with-next', pagination.keepWithNext);
     setBooleanAttribute(element, 'data-office-page-break-before', pagination.pageBreakBefore);
     setBooleanAttribute(element, 'data-office-widow-control', pagination.widowControl);
+    setBooleanAttribute(element, 'data-office-contextual-spacing', pagination.contextualSpacing);
+    setBooleanAttribute(element, 'data-office-default-collapsed', pagination.defaultCollapsed);
+    if (void 0 !== pagination.outlineLevel) element.dataset.officeOutlineLevel = String(pagination.outlineLevel);
+}
+function integerValue(element) {
+    if (!element) return null;
+    const value = Number(attribute(element, 'val') ?? attribute(element, 'w:val'));
+    return Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
 function setBooleanAttribute(element, name, value) {
     if (void 0 !== value) element.setAttribute(name, String(value));
@@ -2195,93 +2593,6 @@ function work_docx_paragraph_spacing_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-function createDocxThemeResolver(themeDocument) {
-    if (!themeDocument) return {
-        colors: new Map(),
-        fonts: new Map()
-    };
-    const fonts = new Map();
-    const fontScheme = firstDescendant(themeDocument, 'fontScheme');
-    addThemeFontFamily(fonts, 'major', fontScheme ? directChild(fontScheme, 'majorFont') : void 0);
-    addThemeFontFamily(fonts, 'minor', fontScheme ? directChild(fontScheme, 'minorFont') : void 0);
-    const colors = new Map();
-    const colorScheme = firstDescendant(themeDocument, 'clrScheme');
-    if (colorScheme) for (const entry of directChildren(colorScheme)){
-        const color = themeColorValue(directChildren(entry)[0]);
-        if (color) colors.set(entry.localName.toLowerCase(), color);
-    }
-    return {
-        colors,
-        fonts
-    };
-}
-function resolveDocxThemeResolver(source) {
-    return isDocxThemeResolver(source) ? source : createDocxThemeResolver(source);
-}
-function docxThemeFont(resolver, key) {
-    return key ? resolver.fonts.get(key.trim().toLowerCase()) : void 0;
-}
-function docxThemeColor(resolver, key, tint, shade) {
-    const color = key ? resolver.colors.get(key.trim().toLowerCase()) : void 0;
-    if (!color) return;
-    const channels = [
-        Number.parseInt(color.slice(0, 2), 16),
-        Number.parseInt(color.slice(2, 4), 16),
-        Number.parseInt(color.slice(4, 6), 16)
-    ];
-    const shadeFactor = hexFactor(shade);
-    const tintFactor = hexFactor(tint);
-    const transformed = channels.map((channel)=>{
-        const shaded = void 0 === shadeFactor ? channel : channel * shadeFactor;
-        const tinted = void 0 === tintFactor ? shaded : shaded + (255 - shaded) * tintFactor;
-        return Math.max(0, Math.min(255, Math.round(tinted)));
-    });
-    return transformed.map((channel)=>channel.toString(16).padStart(2, '0')).join('');
-}
-function addThemeFontFamily(fonts, prefix, family) {
-    if (!family) return;
-    const latin = typeface(directChild(family, 'latin'));
-    const eastAsia = typeface(directChild(family, 'ea')) || scriptTypeface(family, [
-        'Hans',
-        'Hant',
-        'Jpan',
-        'Hang'
-    ]) || latin;
-    const complex = typeface(directChild(family, 'cs')) || latin;
-    if (latin) {
-        fonts.set(`${prefix}ascii`, latin);
-        fonts.set(`${prefix}hansi`, latin);
-    }
-    if (eastAsia) fonts.set(`${prefix}eastasia`, eastAsia);
-    if (complex) fonts.set(`${prefix}bidi`, complex);
-}
-function scriptTypeface(family, scripts) {
-    const fonts = directChildren(family, 'font');
-    for (const script of scripts){
-        const font = fonts.find((candidate)=>drawingAttribute(candidate, "script") === script);
-        const value = font ? typeface(font) : void 0;
-        if (value) return value;
-    }
-}
-function typeface(element) {
-    const value = element ? drawingAttribute(element, 'typeface')?.trim() : void 0;
-    return value || void 0;
-}
-function themeColorValue(element) {
-    if (!element) return;
-    const value = 'sysClr' === element.localName ? drawingAttribute(element, 'lastClr') : drawingAttribute(element, 'val');
-    return value && /^[0-9a-f]{6}$/i.test(value) ? value.toLowerCase() : void 0;
-}
-function drawingAttribute(element, name) {
-    return attribute(element, name) ?? attribute(element, `a:${name}`);
-}
-function hexFactor(value) {
-    if (!value || !/^[0-9a-f]{2}$/i.test(value)) return;
-    return Number.parseInt(value, 16) / 255;
-}
-function isDocxThemeResolver(source) {
-    return Boolean(source && 'colors' in source && source.colors instanceof Map && 'fonts' in source && source.fonts instanceof Map);
-}
 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;
@@ -2331,6 +2642,8 @@ function resolvedRunFormatting(propertySources, theme, runText) {
     let complexFontSize;
     let color;
     let backgroundColor;
+    let themeColor;
+    let themeFill;
     let bold;
     let complexBold;
     let italic;
@@ -2368,21 +2681,38 @@ function resolvedRunFormatting(propertySources, theme, runText) {
         if (colorElement) {
             const value = work_docx_run_formatting_import_wordAttribute(colorElement, 'val')?.trim();
             const themed = docxThemeColor(theme, work_docx_run_formatting_import_wordAttribute(colorElement, 'themeColor'), work_docx_run_formatting_import_wordAttribute(colorElement, 'themeTint'), work_docx_run_formatting_import_wordAttribute(colorElement, 'themeShade'));
-            if (themed) color = `#${themed}`;
-            else if (value?.toLowerCase() === 'auto') color = 'inherit';
-            else if (value && /^[0-9a-f]{6}$/i.test(value)) color = `#${value.toLowerCase()}`;
+            if (themed) {
+                color = `#${themed}`;
+                themeColor = themeReference(colorElement, 'themeColor', 'themeTint', 'themeShade', color);
+            } else if (value?.toLowerCase() === 'auto') {
+                color = 'inherit';
+                themeColor = void 0;
+            } else if (value && /^[0-9a-f]{6}$/i.test(value)) {
+                color = `#${value.toLowerCase()}`;
+                themeColor = void 0;
+            }
         }
         const highlight = directChild(properties, 'highlight');
         if (highlight) {
             const value = work_docx_run_formatting_import_wordAttribute(highlight, 'val')?.trim().toLowerCase();
-            if (value) backgroundColor = wordHighlightColor(value);
+            if (value) {
+                backgroundColor = wordHighlightColor(value);
+                themeFill = void 0;
+            }
         } else {
             const shading = directChild(properties, 'shd');
             const fill = shading ? work_docx_run_formatting_import_wordAttribute(shading, 'fill')?.trim() : void 0;
             const themed = shading ? docxThemeColor(theme, work_docx_run_formatting_import_wordAttribute(shading, 'themeFill'), work_docx_run_formatting_import_wordAttribute(shading, 'themeFillTint'), work_docx_run_formatting_import_wordAttribute(shading, 'themeFillShade')) : void 0;
-            if (themed) backgroundColor = `#${themed}`;
-            else if (fill?.toLowerCase() === 'auto') backgroundColor = 'transparent';
-            else if (fill && /^[0-9a-f]{6}$/i.test(fill)) backgroundColor = `#${fill.toLowerCase()}`;
+            if (themed) {
+                backgroundColor = `#${themed}`;
+                themeFill = themeReference(shading, 'themeFill', 'themeFillTint', 'themeFillShade', backgroundColor);
+            } else if (fill?.toLowerCase() === 'auto') {
+                backgroundColor = 'transparent';
+                themeFill = void 0;
+            } else if (fill && /^[0-9a-f]{6}$/i.test(fill)) {
+                backgroundColor = `#${fill.toLowerCase()}`;
+                themeFill = void 0;
+            }
         }
     }
     const fontSlot = true === complexScriptFormatting || true === rightToLeft ? 'complex' : docxFontSlotForText(runText, fontHint);
@@ -2426,6 +2756,12 @@ function resolvedRunFormatting(propertySources, theme, runText) {
         } : {},
         ...backgroundColor ? {
             backgroundColor
+        } : {},
+        ...themeColor ? {
+            themeColor
+        } : {},
+        ...themeFill ? {
+            themeFill
         } : {}
     };
 }
@@ -2455,7 +2791,11 @@ function formattingMarkup(document, formatting) {
     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;
+    const themeColor = serializeDocxThemeReference(formatting.themeColor ?? null);
+    if (themeColor) span.dataset.officeThemeColor = themeColor;
     if (formatting.backgroundColor) span.style.backgroundColor = formatting.backgroundColor;
+    const themeFill = serializeDocxThemeReference(formatting.themeFill ?? null);
+    if (themeFill) span.dataset.officeThemeFill = themeFill;
     const html = span.outerHTML;
     const tags = [
         ...formatting.bold ? [
@@ -2478,6 +2818,26 @@ function formattingMarkup(document, formatting) {
         ].reverse().map((tag)=>`</${tag}>`).join('')}</span>`
     };
 }
+function themeReference(element, themeName, tintName, shadeName, resolved) {
+    const theme = work_docx_run_formatting_import_wordAttribute(element, themeName)?.trim();
+    if (!theme) return;
+    const tint = normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, tintName));
+    const shade = normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, shadeName));
+    return {
+        theme,
+        resolved,
+        ...tint ? {
+            tint
+        } : {},
+        ...shade ? {
+            shade
+        } : {}
+    };
+}
+function normalizedByteHex(value) {
+    const normalized = value?.trim().toUpperCase();
+    return normalized && /^[0-9A-F]{2}$/.test(normalized) ? normalized : void 0;
+}
 function overriddenBoolean(current, next) {
     return void 0 === next ? current : next;
 }
@@ -2805,18 +3165,21 @@ function markDocxTableCells(document, themeSource, tableStyleSource) {
             ] : []
         ];
         const borders = importedTableCellBorders(cell, layers, theme);
-        const backgroundColor = importedTableCellBackgroundColor(layers, theme);
+        const background = importedTableCellBackgroundColor(layers, theme);
         const verticalAlign = importedTableCellVerticalAlign(layers);
         const margins = importedTableCellMargins(layers);
-        if (!backgroundColor && !verticalAlign && !borders && !margins) continue;
+        if (!background && !verticalAlign && !borders && !margins) continue;
         const paragraph = firstTableCellParagraph(document, cell);
         if (!paragraph) continue;
         const marker = `__A3S_WORK_TABLE_CELL_${cells.length + 1}__`;
         insertCellMarker(document, paragraph, marker);
         cells.push({
             marker,
-            ...backgroundColor ? {
-                backgroundColor
+            ...background ? {
+                backgroundColor: background.color
+            } : {},
+            ...background?.theme ? {
+                themeFill: background.theme
             } : {},
             ...verticalAlign ? {
                 verticalAlign
@@ -2857,6 +3220,8 @@ function applyCellFormat(cell, format) {
         cell.dataset.officeCellFill = format.backgroundColor;
         cell.style.backgroundColor = format.backgroundColor;
     }
+    const themeFill = serializeDocxThemeReference(format.themeFill ?? null);
+    if (themeFill) cell.dataset.officeCellThemeFill = themeFill;
     if (format.verticalAlign) {
         cell.dataset.officeCellVerticalAlign = format.verticalAlign;
         cell.style.verticalAlign = format.verticalAlign;
@@ -2872,6 +3237,8 @@ function applyCellFormat(cell, format) {
             if (border) borders[edge] = {
                 ...border
             };
+            const theme = serializeDocxThemeReference(border?.theme ?? null);
+            if (theme) cell.dataset[`officeCellBorderTheme${capitalize(edge)}`] = theme;
         }
         const rendered = renderDocumentTableBorders(borders);
         for (const [name, value] of Object.entries(rendered))if ('style' !== name) cell.setAttribute(name, value);
@@ -3000,7 +3367,10 @@ function parseBorder(edge, theme) {
     return {
         color,
         style,
-        width: Math.max(0.5, Math.min(6, Math.round(2 * width) / 2))
+        width: Math.max(0.5, Math.min(6, Math.round(2 * width) / 2)),
+        ...themed ? {
+            theme: work_docx_table_cell_import_themeReference(edge, 'themeColor', 'themeTint', 'themeShade', color)
+        } : {}
     };
 }
 function importedTableCellBackgroundColor(layers, theme) {
@@ -3015,7 +3385,36 @@ function importedTableCellBackgroundColor(layers, theme) {
 }
 function tableCellBackgroundColor(shading, theme) {
     const themed = docxThemeColor(theme, attribute(shading, 'themeFill'), attribute(shading, 'themeFillTint'), attribute(shading, 'themeFillShade'));
-    return themed ? `#${themed}` : ooxmlColor(attribute(shading, 'fill'));
+    if (themed) {
+        const color = `#${themed}`;
+        return {
+            color,
+            theme: work_docx_table_cell_import_themeReference(shading, 'themeFill', 'themeFillTint', 'themeFillShade', color)
+        };
+    }
+    const color = ooxmlColor(attribute(shading, 'fill'));
+    return color ? {
+        color
+    } : null;
+}
+function work_docx_table_cell_import_themeReference(element, themeName, tintName, shadeName, resolved) {
+    const theme = attribute(element, themeName)?.trim() ?? '';
+    const tint = work_docx_table_cell_import_normalizedByteHex(attribute(element, tintName));
+    const shade = work_docx_table_cell_import_normalizedByteHex(attribute(element, shadeName));
+    return {
+        theme,
+        resolved,
+        ...tint ? {
+            tint
+        } : {},
+        ...shade ? {
+            shade
+        } : {}
+    };
+}
+function work_docx_table_cell_import_normalizedByteHex(value) {
+    const normalized = value?.trim().toUpperCase();
+    return normalized && /^[0-9A-F]{2}$/.test(normalized) ? normalized : void 0;
 }
 function importedTableCellVerticalAlign(layers) {
     let alignment = null;
@@ -3079,20 +3478,33 @@ function work_docx_table_cell_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
+function capitalize(value) {
+    return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
 const work_docx_table_row_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_table_row_import_WORD_2010_NAMESPACE = 'http://schemas.microsoft.com/office/word/2010/wordml';
 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 work_docx_table_row_import_PIXELS_PER_TWIP = 96 / 1440;
 function markDocxTableRows(document) {
+    const wordRows = descendants(document, 'tr').filter((row)=>DOCX_WORDPROCESSING_NAMESPACES.has(row.namespaceURI ?? ''));
+    const identities = new Map();
+    const identityCounts = work_docx_table_row_import_wordIdentityIdCounts(document);
+    for (const row of wordRows){
+        const identity = wordTableRowIdentity(row);
+        if (identity) identities.set(row, identity);
+    }
     const rows = [];
-    for (const row of descendants(document, 'tr')){
+    for (const row of wordRows){
         const properties = directChild(row, 'trPr');
         const cantSplit = properties ? directChild(properties, 'cantSplit') : void 0;
         const repeatHeader = properties ? directChild(properties, 'tblHeader') : void 0;
         const height = properties ? directChild(properties, 'trHeight') : void 0;
         const rowHeight = height ? work_docx_table_row_import_twipsToPixels(Number(attribute(height, 'val'))) : null;
         const rowHeightRule = tableRowHeightRule(attribute(height ?? row, 'hRule'));
-        if (!cantSplit && !repeatHeader && null === rowHeight) continue;
+        const rowIdentity = identities.get(row);
+        const uniqueIdentity = rowIdentity && 1 === identityCounts.get(rowIdentity.rowId) ? rowIdentity : null;
+        if (!cantSplit && !repeatHeader && null === rowHeight && !uniqueIdentity) continue;
         const paragraph = firstTableRowParagraph(document, row);
         if (!paragraph) continue;
         const marker = `__A3S_WORK_TABLE_ROW_${rows.length + 1}__`;
@@ -3105,6 +3517,7 @@ function markDocxTableRows(document) {
             ...repeatHeader ? {
                 repeatHeader: work_docx_table_row_import_onOffValue(repeatHeader)
             } : {},
+            ...uniqueIdentity ?? {},
             ...null !== rowHeight ? {
                 rowHeight
             } : {},
@@ -3117,6 +3530,18 @@ function markDocxTableRows(document) {
         rows
     };
 }
+function work_docx_table_row_import_wordIdentityIdCounts(document) {
+    const counts = new Map();
+    for (const localName of [
+        'p',
+        'tr'
+    ])for (const element of descendants(document, localName)){
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '')) continue;
+        const paragraphId = normalizeDocumentParagraphId(work_docx_table_row_import_word2010Attribute(element, 'paraId'));
+        if (paragraphId) counts.set(paragraphId, (counts.get(paragraphId) ?? 0) + 1);
+    }
+    return counts;
+}
 function applyImportedDocxTableRowMarkers(document, markers) {
     const rowByMarker = new Map(markers.rows.map((row)=>[
             row.marker,
@@ -3128,6 +3553,7 @@ function applyImportedDocxTableRowMarkers(document, markers) {
         node.data = node.data.replace(TABLE_ROW_MARKER_PATTERN, (marker)=>{
             const properties = rowByMarker.get(marker);
             if (row instanceof HTMLTableRowElement && properties) {
+                applyDocumentTableRowIdentityToElement(row, properties);
                 work_docx_table_row_import_setBooleanAttribute(row, 'data-office-cant-split', properties.cantSplit);
                 work_docx_table_row_import_setBooleanAttribute(row, 'data-office-repeat-header', properties.repeatHeader);
                 if (void 0 !== properties.rowHeight) {
@@ -3149,19 +3575,32 @@ function firstTableRowParagraph(document, row) {
     if (!cell) return null;
     const existing = directChild(cell, 'p') ?? descendants(cell, 'p').find((paragraph)=>work_docx_table_row_import_closestAncestor(paragraph, 'tr') === row);
     if (existing) return existing;
-    const paragraph = document.createElementNS(work_docx_table_row_import_WORD_NAMESPACE, 'w:p');
+    const namespace = cell.namespaceURI ?? work_docx_table_row_import_WORD_NAMESPACE;
+    const prefix = cell.prefix ? `${cell.prefix}:` : '';
+    const paragraph = document.createElementNS(namespace, `${prefix}p`);
     cell.append(paragraph);
     return paragraph;
 }
 function insertRowMarker(document, paragraph, marker) {
-    const run = document.createElementNS(work_docx_table_row_import_WORD_NAMESPACE, 'w:r');
-    const text = document.createElementNS(work_docx_table_row_import_WORD_NAMESPACE, 'w:t');
+    const namespace = paragraph.namespaceURI ?? work_docx_table_row_import_WORD_NAMESPACE;
+    const prefix = paragraph.prefix ? `${paragraph.prefix}:` : '';
+    const run = document.createElementNS(namespace, `${prefix}r`);
+    const text = document.createElementNS(namespace, `${prefix}t`);
     text.setAttributeNS(work_docx_table_row_import_XML_NAMESPACE, 'xml:space', 'preserve');
     text.textContent = marker;
     run.append(text);
     const properties = directChild(paragraph, 'pPr');
     paragraph.insertBefore(run, properties?.nextSibling ?? paragraph.firstChild);
 }
+function wordTableRowIdentity(row) {
+    return normalizeDocumentTableRowIdentity({
+        rowId: work_docx_table_row_import_word2010Attribute(row, 'paraId'),
+        rowTextId: work_docx_table_row_import_word2010Attribute(row, 'textId')
+    });
+}
+function work_docx_table_row_import_word2010Attribute(element, localName) {
+    return Array.from(element.attributes).find((item)=>xmlAttributeLocalName(item) === localName && xmlAttributeNamespace(element, item) === work_docx_table_row_import_WORD_2010_NAMESPACE)?.value ?? null;
+}
 function work_docx_table_row_import_onOffValue(element) {
     const value = (attribute(element, 'val') ?? attribute(element, 'w:val'))?.trim().toLowerCase();
     return '0' !== value && 'false' !== value && 'off' !== value;
@@ -3210,7 +3649,8 @@ function markDocxTableSizing(document, tableStyleSource) {
         tables.push({
             marker,
             geometry: importedTableGeometry(docxTablePropertySources(table, tableStyles)),
-            columnWidths
+            columnWidths,
+            columnPercentages: importedColumnPercentages(table, columnWidths)
         });
     }
     return {
@@ -3231,6 +3671,7 @@ function applyImportedDocxTableSizingMarkers(document, markers) {
                 table.dataset.officeTableImported = 'true';
                 applyDocumentTableGeometryToElement(table, sizing.geometry);
                 if (sizing.columnWidths.length) applyColumnWidths(table, sizing.columnWidths);
+                if (sizing.columnPercentages.length) applyColumnPercentages(table, sizing.columnPercentages);
             }
             return '';
         });
@@ -3341,9 +3782,9 @@ function percentageValue(value) {
 }
 function applyColumnWidths(table, columnWidths) {
     const occupiedUntilRow = [];
-    Array.from(table.rows).forEach((row, rowIndex)=>{
+    ownedTableRows(table).forEach((row, rowIndex)=>{
         let columnIndex = 0;
-        for (const cell of Array.from(row.cells)){
+        for (const cell of ownedTableRowCells(row)){
             while((occupiedUntilRow[columnIndex] ?? 0) > rowIndex)columnIndex += 1;
             const widths = columnWidths.slice(columnIndex, columnIndex + cell.colSpan);
             if (widths.length === cell.colSpan) cell.setAttribute('colwidth', widths.join(','));
@@ -3352,6 +3793,70 @@ function applyColumnWidths(table, columnWidths) {
         }
     });
 }
+function applyColumnPercentages(table, columnPercentages) {
+    const occupiedUntilRow = [];
+    ownedTableRows(table).forEach((row, rowIndex)=>{
+        let columnIndex = 0;
+        for (const cell of ownedTableRowCells(row)){
+            while((occupiedUntilRow[columnIndex] ?? 0) > rowIndex)columnIndex += 1;
+            const percentages = columnPercentages.slice(columnIndex, columnIndex + cell.colSpan);
+            if (percentages.length === cell.colSpan) cell.dataset.officeColumnWidthsPercent = percentages.join(',');
+            if (cell.rowSpan > 1) for(let offset = 0; offset < cell.colSpan; offset += 1)occupiedUntilRow[columnIndex + offset] = rowIndex + cell.rowSpan;
+            columnIndex += cell.colSpan;
+        }
+    });
+}
+function ownedTableRows(table) {
+    return Array.from(table.rows).filter((row)=>row.closest('table') === table);
+}
+function ownedTableRowCells(row) {
+    return Array.from(row.cells).filter((cell)=>cell.closest('tr') === row);
+}
+function importedColumnPercentages(table, columnWidths) {
+    const columnCount = columnWidths.length || logicalTableColumnCount(table);
+    const percentages = Array.from({
+        length: columnCount
+    }, ()=>null);
+    const rows = directChildren(table, 'tr');
+    for (const row of rows){
+        let column = rowGridBefore(row);
+        for (const cell of directChildren(row, 'tc')){
+            const properties = directChild(cell, 'tcPr');
+            const gridSpan = directChild(properties ?? cell, 'gridSpan');
+            const span = Math.max(1, Number(gridSpan ? attribute(gridSpan, 'val') : null) || 1);
+            const width = directChild(properties ?? cell, 'tcW');
+            const total = width && 'pct' === attribute(width, 'type') ? percentageValue(attribute(width, 'w')) : null;
+            if (null !== total) {
+                const physical = columnWidths.slice(column, column + span);
+                const physicalTotal = physical.reduce((sum, value)=>sum + value, 0);
+                for(let offset = 0; offset < span; offset += 1){
+                    if (null !== percentages[column + offset]) continue;
+                    const share = physicalTotal > 0 ? total * ((physical[offset] ?? 0) / physicalTotal) : total / span;
+                    percentages[column + offset] = Math.round(100 * share) / 100;
+                }
+            }
+            column += span;
+        }
+    }
+    return percentages.every((value)=>null !== value && value > 0) ? percentages : [];
+}
+function logicalTableColumnCount(table) {
+    return directChildren(table, 'tr').reduce((maximum, row)=>{
+        const count = directChildren(row, 'tc').reduce((sum, cell)=>{
+            const properties = directChild(cell, 'tcPr');
+            const gridSpan = directChild(properties ?? cell, 'gridSpan');
+            const span = Number(gridSpan ? attribute(gridSpan, 'val') : null);
+            return sum + (Number.isSafeInteger(span) && span > 0 ? span : 1);
+        }, rowGridBefore(row));
+        return Math.max(maximum, count);
+    }, 0);
+}
+function rowGridBefore(row) {
+    const properties = directChild(row, 'trPr');
+    const gridBefore = directChild(properties ?? row, 'gridBefore');
+    const value = Number(gridBefore ? attribute(gridBefore, 'val') : null);
+    return Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
 function firstTableParagraph(document, table) {
     const cell = descendants(table, 'tc').find((candidate)=>work_docx_table_sizing_import_closestAncestor(candidate, 'tbl') === table);
     if (!cell) return null;
@@ -3390,7 +3895,6 @@ function work_docx_table_sizing_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-const work_docx_import_TWIPS_PER_MILLIMETER = 1440 / 25.4;
 const work_docx_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 async function prepareDocxImport(buffer) {
@@ -3413,6 +3917,10 @@ async function prepareDocxImport(buffer) {
             captions: [],
             references: []
         },
+        bookmarkMarkers: {
+            bookmarks: [],
+            references: []
+        },
         changeMarkers: {
             changes: []
         },
@@ -3423,6 +3931,9 @@ async function prepareDocxImport(buffer) {
         fieldMarkers: {
             fields: []
         },
+        equationMarkers: {
+            equations: []
+        },
         citationMarkers: {
             citations: [],
             bibliographies: []
@@ -3433,6 +3944,9 @@ async function prepareDocxImport(buffer) {
         imageLayoutMarkers: {
             images: []
         },
+        paragraphIdentityMarkers: {
+            paragraphs: []
+        },
         paragraphAlignmentMarkers: {
             paragraphs: []
         },
@@ -3445,6 +3959,16 @@ async function prepareDocxImport(buffer) {
         paragraphPaginationMarkers: {
             paragraphs: []
         },
+        paragraphBorderMarkers: {
+            paragraphs: [],
+            invalidCount: 0,
+            spoofedCount: 0
+        },
+        paragraphShadingMarkers: {
+            paragraphs: [],
+            invalidCount: 0,
+            spoofedCount: 0
+        },
         paragraphSpacingMarkers: {
             paragraphs: []
         },
@@ -3469,14 +3993,20 @@ async function prepareDocxImport(buffer) {
     };
     const document = await archive.xml('word/document.xml');
     const pageColor = importDocxPageColor(document);
+    const paragraphIdentityMarkers = markDocxParagraphIdentities(document);
     const numbering = archive.has('word/numbering.xml') ? await archive.xml('word/numbering.xml') : null;
     const commentMarkers = await markDocxComments(document, archive);
     const changeMarkers = markDocxTextChanges(document);
     const captionMarkers = markDocxCaptionFields(document);
+    const bookmarkMarkers = markDocxBookmarks(document);
     const citationMarkers = markDocxCitationFields(document);
     const fieldMarkers = markDocxBodyFields(document);
     const listMarkers = markDocxLists(document, numbering);
-    const imageLayoutMarkers = markDocxImageLayouts(document);
+    const imageLayoutMarkerState = createImportedDocxImageLayoutMarkerState();
+    const imageLayoutMarkers = markDocxImageLayouts(document, imageLayoutMarkerState);
+    const noteImageMarkers = await markDocxNoteImageLayouts(archive, imageLayoutMarkerState);
+    imageLayoutMarkers.images.push(...noteImageMarkers.markers.images);
+    const equationMarkers = await markDocxPackageEquations(archive, document, noteImageMarkers.parts);
     const paragraphStylesDocument = archive.has('word/styles.xml') ? await archive.xml('word/styles.xml') : null;
     const paragraphStyles = createDocxParagraphStyleResolver(paragraphStylesDocument);
     const tableStyles = createDocxTableStyleResolver(paragraphStylesDocument);
@@ -3487,16 +4017,20 @@ async function prepareDocxImport(buffer) {
     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, tableStyles);
+    const settings = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
+    const pageMarginSettings = inspectDocxPageMarginSettings(settings);
+    const theme = createDocxThemeResolver(themeDocument, settings);
+    const paragraphBorderMarkers = markDocxParagraphBorders(document, paragraphStyles, theme, tableStyles);
+    const paragraphShadingMarkers = markDocxParagraphShading(document, paragraphStyles, theme, tableStyles);
+    const runFormattingMarkers = markDocxRunFormatting(document, paragraphStyles, theme, tableStyles);
     const tabStopMarkers = markDocxParagraphTabStops(document, paragraphStyles, tableStyles);
-    const tableCellMarkers = markDocxTableCells(document, themeDocument, tableStyles);
+    const tableCellMarkers = markDocxTableCells(document, theme, tableStyles);
     const tableRowMarkers = markDocxTableRows(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);
     if (!sectionElements.length) return {
-        conversionBuffer: hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document) : buffer,
+        conversionBuffer: hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
         sections: [
             {
                 id: 'document-section-1',
@@ -3505,16 +4039,21 @@ async function prepareDocxImport(buffer) {
         ],
         pageColor,
         captionMarkers,
+        bookmarkMarkers,
         changeMarkers,
         commentMarkers,
         fieldMarkers,
+        equationMarkers: equationMarkers.markers,
         citationMarkers,
         listMarkers,
         imageLayoutMarkers,
+        paragraphIdentityMarkers,
         paragraphAlignmentMarkers,
         paragraphDirectionMarkers,
         paragraphIndentMarkers,
         paragraphPaginationMarkers,
+        paragraphBorderMarkers,
+        paragraphShadingMarkers,
         paragraphSpacingMarkers,
         runFormattingMarkers,
         tabStopMarkers,
@@ -3529,7 +4068,7 @@ async function prepareDocxImport(buffer) {
     const sections = [];
     let previous = fallback;
     for (const [index, element] of sectionElements.entries()){
-        const layout = await parseSectionLayout(element, archive, relationships, previous, oddEvenPageChrome);
+        const layout = await parseSectionLayout(element, archive, relationships, previous, oddEvenPageChrome, theme, pageMarginSettings);
         sections.push({
             id: `document-section-${index + 1}`,
             layout
@@ -3538,20 +4077,25 @@ async function prepareDocxImport(buffer) {
     }
     if (sections.length > 1) addSectionMarkers(document, sectionElements);
     return {
-        conversionBuffer: sections.length > 1 || hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document) : buffer,
+        conversionBuffer: sections.length > 1 || hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
         sections,
         pageColor,
         captionMarkers,
+        bookmarkMarkers,
         changeMarkers,
         commentMarkers,
         fieldMarkers,
+        equationMarkers: equationMarkers.markers,
         citationMarkers,
         listMarkers,
         imageLayoutMarkers,
+        paragraphIdentityMarkers,
         paragraphAlignmentMarkers,
         paragraphDirectionMarkers,
         paragraphIndentMarkers,
         paragraphPaginationMarkers,
+        paragraphBorderMarkers,
+        paragraphShadingMarkers,
         paragraphSpacingMarkers,
         runFormattingMarkers,
         tabStopMarkers,
@@ -3565,6 +4109,9 @@ async function prepareDocxImport(buffer) {
 function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     captions: [],
     references: []
+}, bookmarkMarkers = {
+    bookmarks: [],
+    references: []
 }, changeMarkers = {
     changes: []
 }, commentMarkers = {
@@ -3572,6 +4119,8 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     ranges: []
 }, fieldMarkers = {
     fields: []
+}, equationMarkers = {
+    equations: []
 }, citationMarkers = {
     citations: [],
     bibliographies: []
@@ -3579,6 +4128,8 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     lists: []
 }, imageLayoutMarkers = {
     images: []
+}, paragraphIdentityMarkers = {
+    paragraphs: []
 }, paragraphAlignmentMarkers = {
     paragraphs: []
 }, runFormattingMarkers = {
@@ -3589,6 +4140,14 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     paragraphs: []
 }, paragraphSpacingMarkers = {
     paragraphs: []
+}, paragraphBorderMarkers = {
+    paragraphs: [],
+    invalidCount: 0,
+    spoofedCount: 0
+}, paragraphShadingMarkers = {
+    paragraphs: [],
+    invalidCount: 0,
+    spoofedCount: 0
 }, paragraphPaginationMarkers = {
     paragraphs: []
 }, bibliography, tabStopMarkers = {
@@ -3603,14 +4162,18 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
 }) {
     const document = new DOMParser().parseFromString(html, 'text/html');
     applyImportedDocxRunFormattingMarkers(document, runFormattingMarkers);
+    applyImportedDocxBookmarkMarkers(document, bookmarkMarkers);
     applyImportedDocxCaptionMarkers(document, captionMarkers);
     applyImportedDocxCitationMarkers(document, citationMarkers);
     applyImportedDocxFieldMarkers(document, fieldMarkers);
+    applyImportedDocxEquationMarkers(document, equationMarkers);
     applyImportedDocxListMarkers(document, listMarkers);
     applyImportedDocxImageLayoutMarkers(document, imageLayoutMarkers);
     applyImportedDocxParagraphDirectionMarkers(document, paragraphDirectionMarkers);
     applyImportedDocxParagraphIndentMarkers(document, paragraphIndentMarkers);
     applyImportedDocxParagraphSpacingMarkers(document, paragraphSpacingMarkers);
+    applyImportedDocxParagraphBorderMarkers(document, paragraphBorderMarkers);
+    applyImportedDocxParagraphShadingMarkers(document, paragraphShadingMarkers);
     applyImportedDocxParagraphPaginationMarkers(document, paragraphPaginationMarkers);
     applyImportedDocxParagraphTabStopMarkers(document, tabStopMarkers);
     applyImportedDocxParagraphAlignmentMarkers(document, paragraphAlignmentMarkers);
@@ -3619,6 +4182,7 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     applyImportedDocxTableRowMarkers(document, tableRowMarkers);
     applyImportedDocxChangeMarkers(document, changeMarkers);
     applyImportedDocxCommentMarkers(document, commentMarkers);
+    applyImportedDocxParagraphIdentityMarkers(document, paragraphIdentityMarkers);
     const notes = extractMammothDocumentNotes(document);
     const sourceNodes = Array.from(document.body.childNodes);
     document.body.replaceChildren();
@@ -3643,7 +4207,7 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
         document.body.append(missing);
     }
     placeMammothDocumentNotes(document, notes);
-    return normalizeDocumentCitationsHtml(normalizeDocumentFieldsHtml(normalizeDocumentCaptionsHtml(normalizeDocumentNotesHtml(document.body.innerHTML))), bibliography);
+    return normalizeDocumentBookmarkReferencesHtml(normalizeDocumentBookmarksHtml(normalizeDocumentCitationsHtml(normalizeDocumentFieldsHtml(normalizeDocumentCaptionsHtml(normalizeDocumentNotesHtml(document.body.innerHTML))), bibliography)));
 }
 async function readDocxLayout(buffer) {
     const prepared = await prepareDocxImport(buffer);
@@ -3654,24 +4218,22 @@ async function readDocxLayout(buffer) {
         } : {}
     };
 }
-async function parseSectionLayout(section, archive, relationships, previous, oddEvenPageChrome) {
-    const pageSize = firstDescendant(section, 'pgSz');
-    const width = work_docx_import_numberAttribute(pageSize, 'w');
-    const height = work_docx_import_numberAttribute(pageSize, 'h');
-    const orientation = 'landscape' === attribute(pageSize ?? section, 'orient') || width > 0 && height > 0 && width > height ? 'landscape' : pageSize ? 'portrait' : previous.orientation;
-    const shortEdge = Math.min(width || 11906, height || 16838);
-    const size = pageSize ? Math.abs(shortEdge - 12240) < Math.abs(shortEdge - 11906) ? 'letter' : 'a4' : previous.pageSize;
-    const marginsElement = firstDescendant(section, 'pgMar');
+async function parseSectionLayout(section, archive, relationships, previous, oddEvenPageChrome, theme, pageMarginSettings) {
+    const parsedPageGeometry = parseDocxPageGeometry(section, previous.pageGeometry);
+    const pageGeometry = null === parsedPageGeometry ? previous.pageGeometry : parsedPageGeometry;
+    const parsedPaperSource = parseDocxPaperSource(section, previous.paperSource);
+    const paperSource = null === parsedPaperSource ? previous.paperSource : parsedPaperSource;
     const columnsElement = firstDescendant(section, 'cols');
     const documentGridElement = directChild(section, 'docGrid');
+    const pageBorders = parseDocxPageBorders(section, theme);
+    const parsedPageMargins = parseDocxPageMargins(section, pageMarginSettings, documentPageMarginsForLayout(previous));
+    const pageMargins = null === parsedPageMargins ? documentPageMarginsForLayout(previous) : parsedPageMargins;
     const pageChrome = await importSectionPageChrome(section, archive, relationships, previous, oddEvenPageChrome);
     const pageNumberStart = work_docx_import_numberAttribute(firstDescendant(section, 'pgNumType'), 'start');
-    return {
-        pageSize: size,
-        orientation,
-        margins: marginsElement ? parseMargins(marginsElement, previous.margins) : {
-            ...previous.margins
-        },
+    const layout = {
+        pageSize: previous.pageSize,
+        orientation: previous.orientation,
+        margins: documentPageMarginBody(pageMargins, previous.margins),
         columns: columnsElement ? importDocxColumns(columnsElement, previous.columns) : {
             ...previous.columns
         },
@@ -3682,10 +4244,23 @@ async function parseSectionLayout(section, archive, relationships, previous, odd
                 ...previous.documentGrid
             }
         } : {},
+        ...pageBorders ? {
+            pageBorders
+        } : {},
+        ...pageMargins ? {
+            pageMargins
+        } : {},
+        ...pageGeometry ? {
+            pageGeometry
+        } : {},
+        ...paperSource ? {
+            paperSource
+        } : {},
         breakAfter: parseSectionBreak(firstDescendant(section, 'type')),
         ...pageChrome,
         pageNumberStart: pageNumberStart > 0 ? pageNumberStart : void 0
     };
+    return pageGeometry ? applyDocumentPageGeometry(layout, pageGeometry) : layout;
 }
 function parseDocumentGrid(element) {
     const sourceType = attribute(element, 'type');
@@ -3710,13 +4285,43 @@ function addSectionMarkers(document, sectionElements) {
         paragraph.parentNode.insertBefore(marker, paragraph.nextSibling);
     }
 }
-async function writeDocumentXml(buffer, document) {
+async function writeDocumentXml(buffer, document, additionalParts = []) {
     const zip = await jszip.loadAsync(buffer);
-    zip.file('word/document.xml', new XMLSerializer().serializeToString(document));
+    zip.file('word/document.xml', serializeDocxConversionXml(document));
+    for (const part of additionalParts)zip.file(part.path, serializeDocxConversionXml(part.document));
     return zip.generateAsync({
         type: 'arraybuffer'
     });
 }
+function serializeDocxConversionXml(document) {
+    const dialects = new Map([
+        [
+            'http://purl.oclc.org/ooxml/wordprocessingml/main',
+            'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
+        ],
+        [
+            'http://purl.oclc.org/ooxml/officeDocument/math',
+            'http://schemas.openxmlformats.org/officeDocument/2006/math'
+        ],
+        [
+            'http://purl.oclc.org/ooxml/officeDocument/relationships',
+            'http://schemas.openxmlformats.org/officeDocument/2006/relationships'
+        ],
+        [
+            'http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing',
+            'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing'
+        ],
+        [
+            'http://purl.oclc.org/ooxml/drawingml/main',
+            'http://schemas.openxmlformats.org/drawingml/2006/main'
+        ],
+        [
+            'http://purl.oclc.org/ooxml/drawingml/picture',
+            'http://schemas.openxmlformats.org/drawingml/2006/picture'
+        ]
+    ]);
+    return new XMLSerializer().serializeToString(document).replace(/(\sxmlns(?::[A-Za-z_][A-Za-z0-9_.-]*)?\s*=\s*)(["'])([^"']+)\2/g, (_declaration, assignment, quote, namespace)=>`${assignment}${quote}${dialects.get(namespace) ?? namespace}${quote}`);
+}
 function effectiveSectionProperties(document) {
     return descendants(document, 'sectPr').filter((element)=>!work_docx_import_closestAncestor(element, 'sectPrChange'));
 }
@@ -3741,14 +4346,6 @@ function isSectionMarker(node, index) {
 function sectionMarker(index) {
     return `__A3S_WORK_DOCUMENT_SECTION_${index + 1}__`;
 }
-function parseMargins(element, fallback) {
-    return {
-        top: work_docx_import_twipsToMillimeters(work_docx_import_numberAttribute(element, 'top'), fallback.top),
-        right: work_docx_import_twipsToMillimeters(work_docx_import_numberAttribute(element, 'right'), fallback.right),
-        bottom: work_docx_import_twipsToMillimeters(work_docx_import_numberAttribute(element, 'bottom'), fallback.bottom),
-        left: work_docx_import_twipsToMillimeters(work_docx_import_numberAttribute(element, 'left'), fallback.left)
-    };
-}
 function parseSectionBreak(element) {
     if (!element) return 'nextPage';
     const value = attribute(element, 'val');
@@ -3768,8 +4365,4 @@ function work_docx_import_closestAncestor(element, localName) {
     }
     return null;
 }
-function work_docx_import_twipsToMillimeters(value, fallback) {
-    if (value <= 0) return fallback;
-    return Math.round(value / work_docx_import_TWIPS_PER_MILLIMETER * 10) / 10;
-}
 export { applyDocxSectionsToHtml, prepareDocxImport, readDocxLayout };