@a3s-lab/office 0.1.0

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

@@ -0,0 +1,3116 @@
+import jszip from "jszip";
+import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, childPath, attribute } from "./8715.js";
+import { docxCaptionSequenceKind, docxFieldOccurrences, docxCaptionBookmark, docxFieldResultText, docxCaptionReferenceTarget } from "./0~152.js";
+import { documentContentLayoutProperties, documentPageChromeLegacyFields, normalizeDocumentFieldsHtml, documentInitialSectionLayout, documentSectionDomAttributes, documentCaptionLabel, normalizeDocumentPageChrome, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentCaptionsHtml, normalizeDocumentNotesHtml, documentCitationTagsFromInstruction, docxDocumentFieldKind, createDocumentNoteElement } from "./4704.js";
+import { normalizeDocumentImageAlignment, serializeDocumentTabStops, normalizeDocumentImageLayoutOptions, normalizeDocumentTabStops } from "./0~8155.js";
+import { normalizeDocumentParagraphIndent } from "./0~work-document-paragraph-formatting.js";
+import { readDocxBibliography } from "./0~work-docx-bibliography.js";
+import { importDocxPageColor } from "./0~work-docx-page-color.js";
+const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+function markDocxCaptionFields(document) {
+    const captions = [];
+    const bookmarkTargets = new Map();
+    const paragraphs = descendants(document, 'p');
+    for (const paragraph of paragraphs){
+        const sequence = docxFieldOccurrences(paragraph).map((field)=>({
+                field,
+                kind: docxCaptionSequenceKind(field.instruction)
+            })).find((item)=>Boolean(item.kind));
+        if (!sequence) continue;
+        const bookmark = docxCaptionBookmark(paragraph, sequence.field);
+        const bookmarkName = attribute(bookmark ?? paragraph, 'name')?.trim() ?? '';
+        const id = uniqueCaptionId(bookmarkName, sequence.kind, captions.length + 1, captions);
+        if (bookmarkName) bookmarkTargets.set(bookmarkName, id);
+        const marker = captionMarker(captions.length + 1, id, sequence.kind);
+        insertParagraphBoundaryMarkers(document, paragraph, marker.start, marker.end);
+        captions.push(marker);
+    }
+    const references = [];
+    for (const paragraph of paragraphs)for (const field of docxFieldOccurrences(paragraph)){
+        const bookmarkName = docxCaptionReferenceTarget(field.instruction);
+        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);
+        references.push(marker);
+    }
+    return {
+        captions,
+        references
+    };
+}
+function applyImportedDocxCaptionMarkers(document, markers) {
+    for (const reference of markers.references){
+        const element = document.createElement('span');
+        element.dataset.documentCrossReference = 'true';
+        element.dataset.referenceTargetId = reference.targetId;
+        replaceMarkerRange(document.body, reference.start, reference.end, element);
+    }
+    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);
+        removeCaptionPrefix(block, caption.kind);
+        const element = document.createElement('figcaption');
+        element.dataset.documentCaption = 'true';
+        element.dataset.captionId = caption.id;
+        element.dataset.captionKind = caption.kind;
+        element.className = 'work-document-caption';
+        element.append(...Array.from(block.childNodes));
+        block.replaceWith(element);
+    }
+}
+function hasImportedDocxCaptionMarkers(markers) {
+    return markers.captions.length > 0 || markers.references.length > 0;
+}
+function uniqueCaptionId(bookmark, kind, index, existing) {
+    const base = bookmark ? `docx-caption-${bookmark}` : `docx-${kind}-caption-${index}`;
+    const ids = new Set(existing.map((caption)=>caption.id));
+    if (!ids.has(base)) return base;
+    let suffix = 2;
+    while(ids.has(`${base}-${suffix}`))suffix += 1;
+    return `${base}-${suffix}`;
+}
+function captionMarker(index, id, kind) {
+    return {
+        start: `__A3S_WORK_CAPTION_START_${index}__`,
+        end: `__A3S_WORK_CAPTION_END_${index}__`,
+        id,
+        kind
+    };
+}
+function referenceMarker(index, targetId) {
+    return {
+        start: `__A3S_WORK_REFERENCE_START_${index}__`,
+        end: `__A3S_WORK_REFERENCE_END_${index}__`,
+        targetId
+    };
+}
+function insertParagraphBoundaryMarkers(document, paragraph, start, end) {
+    const firstContent = Array.from(paragraph.children).find((element)=>'pPr' !== element.localName);
+    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) {
+    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_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));
+    return run;
+}
+function markerText(document, text) {
+    const value = document.createElementNS(WORD_NAMESPACE, 'w:t');
+    value.setAttributeNS(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));
+    if (!startNode || !endNode) return null;
+    let current = startNode.parentElement;
+    while(current && current !== root){
+        if (current.contains(endNode) && /^(?:P|DIV|LI)$/.test(current.tagName)) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function replaceMarkerRange(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 false;
+    const range = root.ownerDocument.createRange();
+    range.setStart(startNode, startNode.data.indexOf(start));
+    range.setEnd(endNode, endNode.data.indexOf(end) + end.length);
+    range.deleteContents();
+    range.insertNode(replacement);
+    return true;
+}
+function removeMarkerText(root, marker) {
+    for (const node of textNodes(root))node.data = node.data.replace(marker, '');
+}
+function removeCaptionPrefix(root, kind) {
+    const label = documentCaptionLabel(kind);
+    const source = root.textContent ?? '';
+    const expression = 'table' === kind ? /^\s*(?:表|Table)\s*(?:\d+)?[\s:：.\-–—　]*/i : /^\s*(?:图|Figure|Fig\.?)\s*(?:\d+)?[\s:：.\-–—　]*/i;
+    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)){
+        if (remaining <= 0) break;
+        const removed = Math.min(remaining, node.data.length);
+        node.data = node.data.slice(removed);
+        remaining -= removed;
+    }
+}
+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_change_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_change_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+function markDocxTextChanges(document) {
+    const changes = [];
+    const revisions = [
+        ...descendants(document, 'ins'),
+        ...descendants(document, 'del')
+    ].sort(compareDocumentOrder);
+    for (const revision of revisions){
+        if (!revision.parentNode || closestRevision(revision.parentElement)) continue;
+        const kind = 'del' === revision.localName ? 'deletion' : 'insertion';
+        if (!revisionText(revision, kind)) continue;
+        if ('deletion' === kind) convertDeletedText(document, revision);
+        const index = changes.length + 1;
+        const sourceId = attribute(revision, 'id')?.trim() ?? '';
+        const id = uniqueChangeId(sourceId ? `docx-change-${sourceId}` : `docx-change-${index}`, changes);
+        const marker = {
+            id,
+            kind,
+            author: attribute(revision, 'author')?.trim() || '未知审阅者',
+            date: normalizeDate(attribute(revision, 'date')),
+            start: `__A3S_WORK_CHANGE_START_${index}__`,
+            end: `__A3S_WORK_CHANGE_END_${index}__`
+        };
+        unwrapRevision(document, revision, marker.start, marker.end);
+        changes.push(marker);
+    }
+    return {
+        changes
+    };
+}
+function applyImportedDocxChangeMarkers(document, markers) {
+    for (const marker of markers.changes){
+        const element = document.createElement('deletion' === marker.kind ? 'del' : 'ins');
+        element.dataset.documentChange = 'true';
+        element.dataset.changeKind = marker.kind;
+        element.dataset.changeId = marker.id;
+        element.dataset.changeAuthor = marker.author;
+        element.dataset.changeDate = marker.date;
+        wrapMarkerRange(document.body, marker.start, marker.end, element);
+    }
+}
+function hasImportedDocxChangeMarkers(markers) {
+    return markers.changes.length > 0;
+}
+function revisionText(revision, kind) {
+    const names = 'deletion' === kind ? [
+        'delText',
+        't'
+    ] : [
+        't'
+    ];
+    return names.flatMap((name)=>descendants(revision, name)).map((element)=>element.textContent ?? '').join('');
+}
+function convertDeletedText(document, revision) {
+    for (const deleted of descendants(revision, 'delText')){
+        const text = document.createElementNS(work_docx_change_import_WORD_NAMESPACE, 'w:t');
+        const preserve = deleted.getAttributeNS(work_docx_change_import_XML_NAMESPACE, 'space') ?? deleted.getAttribute('xml:space');
+        if (preserve) text.setAttributeNS(work_docx_change_import_XML_NAMESPACE, 'xml:space', preserve);
+        text.textContent = deleted.textContent;
+        deleted.replaceWith(text);
+    }
+}
+function unwrapRevision(document, revision, start, end) {
+    const parent = revision.parentNode;
+    if (!parent) return;
+    parent.insertBefore(work_docx_change_import_markerRun(document, start), revision);
+    while(revision.firstChild)parent.insertBefore(revision.firstChild, revision);
+    parent.insertBefore(work_docx_change_import_markerRun(document, end), revision);
+    revision.remove();
+}
+function work_docx_change_import_markerRun(document, value) {
+    const run = document.createElementNS(work_docx_change_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_change_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_change_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = value;
+    run.append(text);
+    return run;
+}
+function wrapMarkerRange(root, start, end, wrapper) {
+    const nodes = work_docx_change_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;
+    const startIndex = startNode.data.indexOf(start);
+    const endIndex = endNode.data.indexOf(end);
+    if (startNode === endNode && endIndex < startIndex) return false;
+    const range = root.ownerDocument.createRange();
+    range.setStart(startNode, startIndex);
+    range.setEnd(endNode, endIndex + end.length);
+    const content = range.extractContents();
+    work_docx_change_import_removeMarkerText(content, start);
+    work_docx_change_import_removeMarkerText(content, end);
+    wrapper.append(content);
+    range.insertNode(wrapper);
+    return true;
+}
+function work_docx_change_import_removeMarkerText(root, marker) {
+    for (const node of work_docx_change_import_textNodes(root))node.data = node.data.replace(marker, '');
+}
+function work_docx_change_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;
+}
+function closestRevision(element) {
+    let current = element;
+    while(current){
+        if ('ins' === current.localName || 'del' === current.localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function uniqueChangeId(base, changes) {
+    const ids = new Set(changes.map((change)=>change.id));
+    if (!ids.has(base)) return base;
+    let suffix = 2;
+    while(ids.has(`${base}-${suffix}`))suffix += 1;
+    return `${base}-${suffix}`;
+}
+function normalizeDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+function compareDocumentOrder(left, right) {
+    if (left === right) return 0;
+    return left.compareDocumentPosition(right) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+}
+const work_docx_citation_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_citation_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+function markDocxCitationFields(document) {
+    const citations = [];
+    const bibliographies = [];
+    for (const field of docxFieldOccurrences(document)){
+        if (!canMarkField(field)) continue;
+        const tags = documentCitationTagsFromInstruction(field.instruction);
+        if (tags.length) {
+            const index = citations.length + 1;
+            const marker = {
+                start: `__A3S_WORK_CITATION_START_${index}__`,
+                end: `__A3S_WORK_CITATION_END_${index}__`,
+                id: `docx-citation-${index}`,
+                instruction: field.instruction,
+                tags,
+                display: docxFieldResultText(field)
+            };
+            work_docx_citation_import_insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
+            citations.push(marker);
+            continue;
+        }
+        if (/^\s*BIBLIOGRAPHY\b/i.test(field.instruction)) {
+            const index = bibliographies.length + 1;
+            const marker = {
+                start: `__A3S_WORK_BIBLIOGRAPHY_START_${index}__`,
+                end: `__A3S_WORK_BIBLIOGRAPHY_END_${index}__`,
+                id: `docx-bibliography-${index}`,
+                instruction: field.instruction,
+                display: docxFieldResultText(field)
+            };
+            work_docx_citation_import_insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
+            bibliographies.push(marker);
+        }
+    }
+    return {
+        citations,
+        bibliographies
+    };
+}
+function applyImportedDocxCitationMarkers(document, markers) {
+    for (const citation of markers.citations){
+        const element = document.createElement('span');
+        element.dataset.documentCitation = 'true';
+        element.dataset.citationId = citation.id;
+        element.dataset.citationTags = citation.tags.join(' ');
+        element.dataset.citationInstruction = citation.instruction;
+        const convertedDisplay = work_docx_citation_import_replaceMarkerRange(document.body, citation.start, citation.end, element);
+        const display = citation.display.trim() || convertedDisplay.trim();
+        element.dataset.citationDisplay = display;
+        element.textContent = display;
+    }
+    for (const bibliography of markers.bibliographies)replaceBibliographyMarkerRange(document.body, bibliography);
+}
+function hasImportedDocxCitationMarkers(markers) {
+    return markers.citations.length > 0 || markers.bibliographies.length > 0;
+}
+function canMarkField(field) {
+    return field.start !== field.end || 'fldSimple' === field.start.localName;
+}
+function work_docx_citation_import_insertFieldBoundaryMarkers(document, field, start, end) {
+    if ('fldChar' === field.start.localName && 'fldChar' === field.end.localName) {
+        field.start.parentNode?.insertBefore(work_docx_citation_import_markerText(document, start), field.start);
+        field.end.parentNode?.insertBefore(work_docx_citation_import_markerText(document, end), field.end.nextSibling);
+        return;
+    }
+    field.start.parentNode?.insertBefore(work_docx_citation_import_markerRun(document, start), field.start);
+    field.end.parentNode?.insertBefore(work_docx_citation_import_markerRun(document, end), field.end.nextSibling);
+}
+function work_docx_citation_import_markerRun(document, text) {
+    const run = document.createElementNS(work_docx_citation_import_WORD_NAMESPACE, 'w:r');
+    run.append(work_docx_citation_import_markerText(document, text));
+    return run;
+}
+function work_docx_citation_import_markerText(document, text) {
+    const value = document.createElementNS(work_docx_citation_import_WORD_NAMESPACE, 'w:t');
+    value.setAttributeNS(work_docx_citation_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    value.textContent = text;
+    return value;
+}
+function work_docx_citation_import_replaceMarkerRange(root, start, end, replacement) {
+    const nodes = work_docx_citation_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 '';
+    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();
+    work_docx_citation_import_removeMarkerText(content, start);
+    work_docx_citation_import_removeMarkerText(content, end);
+    const display = content.textContent ?? '';
+    range.deleteContents();
+    range.insertNode(replacement);
+    return display;
+}
+function replaceBibliographyMarkerRange(root, marker) {
+    const nodes = work_docx_citation_import_textNodes(root);
+    const startNode = nodes.find((node)=>node.data.includes(marker.start));
+    const endNode = nodes.find((node)=>node.data.includes(marker.end));
+    if (!startNode || !endNode) return false;
+    const startBlock = closestHtmlBlock(startNode.parentElement, root);
+    const endBlock = closestHtmlBlock(endNode.parentElement, root);
+    if (!startBlock || !endBlock || startBlock.parentElement !== endBlock.parentElement) return false;
+    const blocks = [];
+    let current = startBlock;
+    while(current){
+        if (current instanceof HTMLElement) blocks.push(current);
+        if (current === endBlock) break;
+        current = current.nextElementSibling;
+    }
+    if (!blocks.length || blocks.at(-1) !== endBlock) return false;
+    const convertedDisplay = blocks.map((block)=>block.textContent ?? '').join('\n').replace(marker.start, '').replace(marker.end, '').trim();
+    const section = root.ownerDocument.createElement('section');
+    section.dataset.documentBibliography = 'true';
+    section.dataset.bibliographyId = marker.id;
+    section.dataset.bibliographyInstruction = marker.instruction;
+    section.dataset.bibliographyDisplay = marker.display.trim() || convertedDisplay;
+    section.className = 'work-document-bibliography';
+    const heading = root.ownerDocument.createElement('h2');
+    heading.textContent = '参考文献';
+    const paragraph = root.ownerDocument.createElement('p');
+    paragraph.textContent = marker.display.trim() || convertedDisplay || '尚无文献源';
+    section.append(heading, paragraph);
+    startBlock.parentElement?.insertBefore(section, startBlock);
+    for (const block of blocks)block.remove();
+    return true;
+}
+function closestHtmlBlock(element, root) {
+    let current = element;
+    while(current && current !== root){
+        if (/^(?:P|DIV|LI|SECTION)$/.test(current.tagName)) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function work_docx_citation_import_removeMarkerText(root, marker) {
+    for (const node of work_docx_citation_import_textNodes(root))node.data = node.data.replace(marker, '');
+}
+function work_docx_citation_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_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) {
+    if (!archive.has('word/comments.xml')) return {
+        comments: [],
+        ranges: []
+    };
+    const definitions = await readCommentDefinitions(archive);
+    const bySourceId = new Map(definitions.map((definition)=>[
+            definition.sourceId,
+            definition
+        ]));
+    const workIds = new Map();
+    const ranges = [];
+    const comments = [];
+    const starts = descendants(document, 'commentRangeStart').sort(work_docx_comment_import_compareDocumentOrder);
+    for (const start of starts){
+        const sourceId = attribute(start, 'id')?.trim() ?? '';
+        if (!sourceId) continue;
+        const end = descendants(document, 'commentRangeEnd').find((candidate)=>attribute(candidate, 'id') === sourceId && Boolean(start.compareDocumentPosition(candidate) & Node.DOCUMENT_POSITION_FOLLOWING));
+        if (!end?.parentNode || !start.parentNode) continue;
+        const workId = workIds.get(sourceId) ?? uniqueWorkCommentId(`docx-comment-${sourceId}`, comments);
+        if (!workIds.has(sourceId)) {
+            workIds.set(sourceId, workId);
+            comments.push(toWorkComment(workId, bySourceId.get(sourceId), definitions));
+        }
+        const index = ranges.length + 1;
+        const range = {
+            id: workId,
+            start: `__A3S_WORK_COMMENT_START_${index}__`,
+            end: `__A3S_WORK_COMMENT_END_${index}__`
+        };
+        start.parentNode.insertBefore(work_docx_comment_import_markerRun(document, range.start), start);
+        end.parentNode.insertBefore(work_docx_comment_import_markerRun(document, range.end), end.nextSibling);
+        start.remove();
+        end.remove();
+        for (const reference of descendants(document, 'commentReference').filter((candidate)=>attribute(candidate, 'id') === sourceId))reference.remove();
+        ranges.push(range);
+    }
+    return {
+        comments,
+        ranges
+    };
+}
+function applyImportedDocxCommentMarkers(document, markers) {
+    for (const marker of markers.ranges)wrapTextBetweenMarkers(document.body, marker.start, marker.end, ()=>{
+        const element = document.createElement('span');
+        element.dataset.documentComment = 'true';
+        element.dataset.commentId = marker.id;
+        return element;
+    });
+}
+function hasImportedDocxCommentMarkers(markers) {
+    return markers.ranges.length > 0;
+}
+async function readCommentDefinitions(archive) {
+    const document = await archive.xml('word/comments.xml');
+    const extended = await readCommentExtended(archive);
+    return descendants(document, 'comment').map((comment)=>{
+        const paragraphs = descendants(comment, 'p');
+        const paraId = attribute(paragraphs.at(-1) ?? comment, 'paraId')?.trim() ?? '';
+        const metadata = extended.get(paraId);
+        return {
+            sourceId: attribute(comment, 'id')?.trim() ?? '',
+            author: attribute(comment, 'author')?.trim() || '未知审阅者',
+            date: work_docx_comment_import_normalizeDate(attribute(comment, 'date')),
+            text: commentText(comment),
+            paraId,
+            parentParaId: metadata?.parentParaId ?? '',
+            resolved: metadata?.resolved ?? false
+        };
+    });
+}
+async function readCommentExtended(archive) {
+    if (!archive.has('word/commentsExtended.xml')) return new Map();
+    const document = await archive.xml('word/commentsExtended.xml');
+    return new Map(descendants(document, 'commentEx').map((comment)=>{
+        const paraId = attribute(comment, 'paraId')?.trim() ?? '';
+        return [
+            paraId,
+            {
+                parentParaId: attribute(comment, 'paraIdParent')?.trim() ?? '',
+                resolved: '1' === attribute(comment, 'done') || 'true' === attribute(comment, 'done')
+            }
+        ];
+    }).filter(([paraId])=>Boolean(paraId)));
+}
+function toWorkComment(id, root, definitions) {
+    if (!root) return {
+        id,
+        author: '未知审阅者',
+        date: '',
+        text: '此批注的内容无法读取。',
+        resolved: false
+    };
+    const replies = definitions.filter((definition)=>definition !== root && commentRoot(definition, definitions) === root).map((definition)=>({
+            id: `docx-comment-reply-${definition.sourceId}`,
+            author: definition.author,
+            date: definition.date,
+            text: definition.text
+        }));
+    return {
+        id,
+        author: root.author,
+        date: root.date,
+        text: root.text,
+        resolved: root.resolved,
+        replies: replies.length ? replies : void 0
+    };
+}
+function commentRoot(definition, definitions) {
+    const byParaId = new Map(definitions.map((item)=>[
+            item.paraId,
+            item
+        ]));
+    const visited = new Set();
+    let current = definition;
+    while(current.parentParaId && !visited.has(current.parentParaId)){
+        visited.add(current.parentParaId);
+        const parent = byParaId.get(current.parentParaId);
+        if (!parent) break;
+        current = parent;
+    }
+    return current;
+}
+function commentText(comment) {
+    const paragraphs = descendants(comment, 'p');
+    const text = paragraphs.map((paragraph)=>descendants(paragraph, 't').map((node)=>node.textContent ?? '').join('').trim()).filter(Boolean).join('\n');
+    return text || '（空批注）';
+}
+function work_docx_comment_import_markerRun(document, value) {
+    const run = document.createElementNS(work_docx_comment_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_comment_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_comment_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = value;
+    run.append(text);
+    return run;
+}
+function wrapTextBetweenMarkers(root, startMarker, endMarker, createWrapper) {
+    const nodes = work_docx_comment_import_textNodes(root);
+    const startNode = nodes.find((node)=>node.data.includes(startMarker));
+    const endNode = nodes.find((node)=>node.data.includes(endMarker));
+    if (!startNode || !endNode) return false;
+    const startNodeIndex = nodes.indexOf(startNode);
+    const endNodeIndex = nodes.indexOf(endNode);
+    const startIndex = startNode.data.indexOf(startMarker);
+    const endIndex = endNode.data.indexOf(endMarker);
+    if (startNodeIndex > endNodeIndex || startNode === endNode && endIndex < startIndex + startMarker.length) return false;
+    const startOffset = startIndex;
+    let endOffset = endIndex;
+    if (startNode === endNode) {
+        const value = startNode.data;
+        endOffset = endIndex - startMarker.length;
+        startNode.data = value.slice(0, startIndex) + value.slice(startIndex + startMarker.length, endIndex) + value.slice(endIndex + endMarker.length);
+    } else {
+        startNode.data = startNode.data.slice(0, startIndex) + startNode.data.slice(startIndex + startMarker.length);
+        endNode.data = endNode.data.slice(0, endIndex) + endNode.data.slice(endIndex + endMarker.length);
+    }
+    let wrapped = false;
+    for(let index = startNodeIndex; index <= endNodeIndex; index += 1){
+        const node = nodes[index];
+        const from = index === startNodeIndex ? startOffset : 0;
+        const to = index === endNodeIndex ? endOffset : node.data.length;
+        if (!(from >= to) && node.parentNode) {
+            wrapTextSegment(node, from, to, createWrapper());
+            wrapped = true;
+        }
+    }
+    return wrapped;
+}
+function wrapTextSegment(node, from, to, wrapper) {
+    let selected = node;
+    if (from > 0) selected = node.splitText(from);
+    const length = to - from;
+    if (length < selected.data.length) selected.splitText(length);
+    selected.parentNode?.insertBefore(wrapper, selected);
+    wrapper.append(selected);
+}
+function work_docx_comment_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;
+}
+function uniqueWorkCommentId(base, comments) {
+    const ids = new Set(comments.map((comment)=>comment.id));
+    if (!ids.has(base)) return base;
+    let suffix = 2;
+    while(ids.has(`${base}-${suffix}`))suffix += 1;
+    return `${base}-${suffix}`;
+}
+function work_docx_comment_import_normalizeDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+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 [];
+        const marker = {
+            start: `__A3S_WORK_FIELD_START_${index + 1}__`,
+            end: `__A3S_WORK_FIELD_END_${index + 1}__`,
+            id: `docx-field-${index + 1}`,
+            kind,
+            instruction: field.instruction,
+            display: docxFieldResultText(field)
+        };
+        work_docx_field_import_insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
+        return [
+            marker
+        ];
+    });
+    return {
+        fields
+    };
+}
+function applyImportedDocxFieldMarkers(document, markers) {
+    for (const field of markers.fields){
+        const element = document.createElement('span');
+        element.dataset.documentField = 'true';
+        element.dataset.fieldId = field.id;
+        element.dataset.fieldKind = field.kind;
+        element.dataset.fieldInstruction = field.instruction;
+        const convertedDisplay = work_docx_field_import_replaceMarkerRange(document.body, field.start, field.end, element);
+        const display = field.display.trim() || convertedDisplay.trim();
+        element.dataset.fieldDisplay = display;
+        element.textContent = display;
+    }
+}
+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);
+        field.end.parentNode?.insertBefore(work_docx_field_import_markerText(document, end), field.end.nextSibling);
+        return;
+    }
+    field.start.parentNode?.insertBefore(work_docx_field_import_markerRun(document, start), field.start);
+    field.end.parentNode?.insertBefore(work_docx_field_import_markerRun(document, end), field.end.nextSibling);
+}
+function work_docx_field_import_markerRun(document, text) {
+    const run = document.createElementNS(work_docx_field_import_WORD_NAMESPACE, 'w:r');
+    run.append(work_docx_field_import_markerText(document, text));
+    return run;
+}
+function work_docx_field_import_markerText(document, text) {
+    const value = document.createElementNS(work_docx_field_import_WORD_NAMESPACE, 'w:t');
+    value.setAttributeNS(work_docx_field_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    value.textContent = text;
+    return value;
+}
+function work_docx_field_import_replaceMarkerRange(root, start, end, replacement) {
+    const nodes = work_docx_field_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 '';
+    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();
+    work_docx_field_import_removeMarkerText(content, start);
+    work_docx_field_import_removeMarkerText(content, end);
+    const display = content.textContent ?? '';
+    range.deleteContents();
+    range.insertNode(replacement);
+    return display;
+}
+function work_docx_field_import_removeMarkerText(root, marker) {
+    for (const node of work_docx_field_import_textNodes(root))node.data = node.data.replace(marker, '');
+}
+function work_docx_field_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;
+}
+function extractMammothDocumentNotes(document) {
+    const definitions = extractDefinitions(document);
+    const notes = new Map();
+    const counters = {
+        footnote: 0,
+        endnote: 0
+    };
+    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 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 definitions;
+}
+function noteKindFromTarget(target) {
+    if (target.startsWith('footnote-')) return 'footnote';
+    if (target.startsWith('endnote-')) return 'endnote';
+    return null;
+}
+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;
+function markDocxLists(document, numbering) {
+    if (!numbering) return {
+        lists: []
+    };
+    const abstractNumbering = new Map(descendants(numbering, 'abstractNum').flatMap((element)=>{
+        const id = integerAttribute(element, 'abstractNumId');
+        return null === id ? [] : [
+            [
+                id,
+                element
+            ]
+        ];
+    }));
+    const concreteNumbering = new Map(descendants(numbering, 'num').flatMap((element)=>{
+        const id = integerAttribute(element, 'numId');
+        return null === id ? [] : [
+            [
+                id,
+                element
+            ]
+        ];
+    }));
+    const seen = new Set();
+    const lists = [];
+    for (const paragraph of descendants(document, 'p')){
+        const properties = directChild(paragraph, 'pPr');
+        const numberingProperties = properties ? directChild(properties, 'numPr') : void 0;
+        const numId = integerAttribute(numberingProperties ? directChild(numberingProperties, 'numId') : null, 'val');
+        if (null === numId) continue;
+        const level = integerAttribute(numberingProperties ? directChild(numberingProperties, 'ilvl') : null, 'val') ?? 0;
+        const key = `${numId}:${level}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const concrete = concreteNumbering.get(numId);
+        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 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,
+            ...type ? {
+                type
+            } : {},
+            ...bulletStyle ? {
+                bulletStyle
+            } : {}
+        });
+    }
+    return {
+        lists
+    };
+}
+function applyImportedDocxListMarkers(document, markers) {
+    const listByMarker = new Map(markers.lists.map((list)=>[
+            list.marker,
+            list
+        ]));
+    for (const node of work_docx_list_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_LIST_START_')) continue;
+        const item = node.parentElement?.closest('li');
+        const list = item?.parentElement;
+        node.data = node.data.replace(LIST_START_MARKER_PATTERN, (marker)=>{
+            const imported = listByMarker.get(marker);
+            if (imported && list instanceof HTMLElement) {
+                if ('ol' === list.tagName.toLowerCase()) {
+                    if (imported.start > 1) list.setAttribute('start', String(imported.start));
+                    if (imported.type) list.setAttribute('type', imported.type);
+                }
+                if ('ul' === list.tagName.toLowerCase() && imported.bulletStyle) {
+                    list.dataset.officeBulletStyle = imported.bulletStyle;
+                    list.style.listStyleType = imported.bulletStyle;
+                }
+            }
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxListMarkers(markers) {
+    return markers.lists.length > 0;
+}
+function effectiveListStart(concrete, abstract, level) {
+    const override = concrete ? descendants(concrete, 'lvlOverride').find((candidate)=>integerAttribute(candidate, 'ilvl') === level) : void 0;
+    const overrideStart = integerAttribute(override ? directChild(override, 'startOverride') : null, 'val');
+    if (null !== overrideStart) return overrideStart;
+    const overrideLevel = override ? directChild(override, 'lvl') : void 0;
+    const abstractLevel = abstract ? descendants(abstract, 'lvl').find((candidate)=>integerAttribute(candidate, 'ilvl') === level) : void 0;
+    return integerAttribute(overrideLevel ? directChild(overrideLevel, 'start') : null, 'val') ?? integerAttribute(abstractLevel ? directChild(abstractLevel, 'start') : null, 'val') ?? 1;
+}
+function effectiveOrderedListType(concrete, abstract, level) {
+    const override = concrete ? descendants(concrete, 'lvlOverride').find((candidate)=>integerAttribute(candidate, 'ilvl') === level) : void 0;
+    const overrideLevel = override ? directChild(override, 'lvl') : void 0;
+    const abstractLevel = abstract ? descendants(abstract, 'lvl').find((candidate)=>integerAttribute(candidate, 'ilvl') === level) : void 0;
+    const format = stringAttribute(overrideLevel ? directChild(overrideLevel, 'numFmt') : null, 'val') ?? stringAttribute(abstractLevel ? directChild(abstractLevel, 'numFmt') : null, 'val');
+    if ('lowerLetter' === format) return 'a';
+    if ('upperLetter' === format) return 'A';
+    if ('lowerRoman' === format) return 'i';
+    if ('upperRoman' === format) return 'I';
+}
+function effectiveBulletListStyle(concrete, abstract, level) {
+    const definition = effectiveListLevel(concrete, abstract, level);
+    const format = stringAttribute(definition ? directChild(definition, 'numFmt') : null, 'val');
+    if ('bullet' !== format) return;
+    const marker = stringAttribute(definition ? directChild(definition, 'lvlText') : null, 'val') ?? '';
+    if (/^[o○◦\uF06F]$/u.test(marker)) return 'circle';
+    if (/^[■▪□\uF0A7]$/u.test(marker)) return 'square';
+    return 'disc';
+}
+function effectiveListLevel(concrete, abstract, level) {
+    const override = concrete ? descendants(concrete, 'lvlOverride').find((candidate)=>integerAttribute(candidate, 'ilvl') === level) : void 0;
+    return (override ? directChild(override, 'lvl') : void 0) ?? (abstract ? descendants(abstract, 'lvl').find((candidate)=>integerAttribute(candidate, 'ilvl') === level) : void 0);
+}
+function insertParagraphMarker(document, paragraph, marker) {
+    const run = document.createElementNS(work_docx_list_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_list_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_list_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 integerAttribute(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 >= 0 ? value : null;
+}
+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 work_docx_list_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_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)
+            })
+        });
+    }
+    return {
+        images
+    };
+}
+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.applied = true;
+        }
+    }
+    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`);
+}
+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();
+}
+async function importSectionPageChrome(section, archive, documentRelationships, previous, oddEvenEnabled) {
+    const fallback = normalizeDocumentPageChrome(previous.pageChrome, previous);
+    const variants = await Promise.all([
+        'default',
+        'first',
+        'even'
+    ].map(async (variant)=>{
+        const content = await importVariant(section, variant, archive, documentRelationships, fallback[variant]);
+        return [
+            variant,
+            content
+        ];
+    }));
+    const hasFirstReferences = hasVariantReference(section, 'first');
+    const hasEvenReferences = hasVariantReference(section, 'even');
+    const pageChrome = normalizeDocumentPageChrome({
+        differentFirstPage: enabledElement(firstDescendant(section, 'titlePg')) || hasFirstReferences,
+        differentOddEvenPages: oddEvenEnabled || hasEvenReferences,
+        ...Object.fromEntries(variants)
+    });
+    return {
+        pageChrome,
+        ...documentPageChromeLegacyFields(pageChrome)
+    };
+}
+function documentUsesOddEvenPageChrome(settings) {
+    return Boolean(settings && descendants(settings, 'evenAndOddHeaders').some(enabledElement));
+}
+async function importVariant(section, variant, archive, documentRelationships, fallback) {
+    const header = await importReferencedPart(section, 'headerReference', variant, archive, documentRelationships);
+    const footer = await importReferencedPart(section, 'footerReference', variant, archive, documentRelationships);
+    const hasImportedPart = Boolean(header || footer);
+    return {
+        headerHtml: header?.html ?? fallback.headerHtml,
+        footerHtml: footer?.html ?? fallback.footerHtml,
+        showPageNumber: hasImportedPart ? Boolean(header?.showPageNumber || footer?.showPageNumber) : fallback.showPageNumber
+    };
+}
+async function importReferencedPart(section, referenceName, variant, archive, documentRelationships) {
+    const reference = directChildren(section, referenceName).find((element)=>(attribute(element, 'type') ?? 'default') === variant);
+    const relationship = documentRelationships.get(attribute(reference ?? section, 'r:id') ?? '');
+    if (!relationship || 'External' === relationship.targetMode || !archive.has(relationship.target)) return null;
+    const document = await archive.xml(relationship.target);
+    return {
+        html: await pageChromePartHtml(document, archive, relationship.target),
+        showPageNumber: containsPageNumber(document)
+    };
+}
+async function pageChromePartHtml(document, archive, partPath) {
+    const relationships = await archive.relationships(partPath);
+    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));
+    }
+    return blocks.join('');
+}
+async function paragraphHtml(paragraph, archive, relationships) {
+    const alignmentValue = attribute(firstDescendant(directChild(paragraph, 'pPr'), '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,
+        instruction: '',
+        separated: false,
+        skipResult: false
+    };
+    let html = '';
+    for (const child of directChildren(paragraph))if ('pPr' !== child.localName) {
+        if ('hyperlink' === child.localName) {
+            const content = await containerRunsHtml(child, field, archive, relationships);
+            const relationship = relationships.get(attribute(child, 'r:id') ?? '');
+            const anchor = attribute(child, 'anchor');
+            const href = relationship?.targetMode === 'External' ? relationship.target : anchor ? `#${anchor}` : '';
+            html += href ? `<a href="${escapeHtml(href)}">${content}</a>` : content;
+            continue;
+        }
+        if ('fldSimple' === child.localName) {
+            const instruction = attribute(child, 'instr') ?? '';
+            if (!/\bPAGE\b/i.test(instruction)) html += await containerRunsHtml(child, field, archive, relationships);
+            continue;
+        }
+        html += await containerRunsHtml(child, field, archive, relationships);
+    }
+    return `<p${alignment ? ` style="text-align: ${alignment}"` : ''}>${html}</p>`;
+}
+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);
+    return html;
+}
+async function runHtml(run, field, archive, relationships) {
+    let content = '';
+    for (const child of directChildren(run)){
+        if ('fldChar' === child.localName) {
+            updateFieldState(field, attribute(child, 'fldCharType'));
+            continue;
+        }
+        if ('instrText' === child.localName) {
+            if (field.active && !field.separated) field.instruction += child.textContent ?? '';
+            continue;
+        }
+        if (fieldContentVisible(field)) {
+            if ('t' === child.localName) content += escapeHtml(child.textContent ?? '');
+            if ('tab' === child.localName) content += '&#9;';
+            if ('br' === child.localName || 'cr' === child.localName) content += '<br>';
+            if ('drawing' === child.localName) content += await drawingHtml(child, archive, relationships);
+        }
+    }
+    if (!content) return '';
+    const properties = directChild(run, 'rPr');
+    if (enabledElement(directChild(properties ?? run, 'b'))) content = `<strong>${content}</strong>`;
+    if (enabledElement(directChild(properties ?? run, 'i'))) content = `<em>${content}</em>`;
+    const underline = directChild(properties ?? run, 'u');
+    if (underline && 'none' !== attribute(underline, 'val')) content = `<u>${content}</u>`;
+    if (enabledElement(directChild(properties ?? run, 'strike')) || enabledElement(directChild(properties ?? run, 'dstrike'))) content = `<s>${content}</s>`;
+    const verticalAlign = attribute(directChild(properties ?? run, 'vertAlign') ?? run, 'val');
+    if ("superscript" === verticalAlign) content = `<sup>${content}</sup>`;
+    if ("subscript" === verticalAlign) content = `<sub>${content}</sub>`;
+    const color = attribute(directChild(properties ?? run, 'color') ?? run, 'val');
+    if (color && /^[0-9a-f]{6}$/i.test(color)) content = `<span style="color: #${color}">${content}</span>`;
+    return content;
+}
+async function drawingHtml(drawing, archive, relationships) {
+    const relationship = relationships.get(attribute(firstDescendant(drawing, 'blip') ?? drawing, 'embed') ?? '');
+    if (!relationship || 'External' === relationship.targetMode || !archive.has(relationship.target)) return '';
+    const source = bytesToDataUrl(await archive.bytes(relationship.target), contentTypeForPart(relationship.target));
+    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}"` : ''}>`;
+}
+async function tableHtml(table, archive, relationships) {
+    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)));
+            cells.push(`<td>${paragraphs.join('')}</td>`);
+        }
+        rows.push(`<tr>${cells.join('')}</tr>`);
+    }
+    return `<table><tbody>${rows.join('')}</tbody></table>`;
+}
+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') ?? ''));
+}
+function hasVariantReference(section, variant) {
+    return [
+        ...directChildren(section, 'headerReference'),
+        ...directChildren(section, 'footerReference')
+    ].some((element)=>(attribute(element, 'type') ?? 'default') === variant);
+}
+function enabledElement(element) {
+    if (!element) return false;
+    const value = attribute(element, 'val')?.toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function escapeHtml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+}
+function updateFieldState(field, fieldType) {
+    if ('begin' === fieldType) {
+        field.active = true;
+        field.instruction = '';
+        field.separated = false;
+        field.skipResult = false;
+        return;
+    }
+    if ('separate' === fieldType && field.active) {
+        field.separated = true;
+        field.skipResult = /\bPAGE\b/i.test(field.instruction);
+        return;
+    }
+    if ('end' === fieldType) {
+        field.active = false;
+        field.instruction = '';
+        field.separated = false;
+        field.skipResult = false;
+    }
+}
+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) {
+    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'));
+    if (directProperties) sources.push(directProperties);
+    return sources;
+}
+function docxRunPropertySources(paragraphProperties, runProperties, resolver) {
+    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'));
+    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_paragraph_direction_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_direction_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_DIRECTION_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_DIRECTION_\d+__/g;
+function markDocxParagraphDirections(document, styleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles);
+        const direction = paragraphDirection(sources);
+        if (!direction) continue;
+        properties ??= insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_DIRECTION_${paragraphs.length + 1}__`;
+        work_docx_paragraph_direction_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            direction
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphDirectionMarkers(document, markers) {
+    const directionByMarker = new Map(markers.paragraphs.map(({ marker, direction })=>[
+            marker,
+            direction
+        ]));
+    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);
+        node.data = node.data.replace(PARAGRAPH_DIRECTION_MARKER_PATTERN, (marker)=>{
+            const direction = directionByMarker.get(marker);
+            if (block && direction) block.setAttribute('dir', direction);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphDirectionMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function paragraphDirection(propertySources) {
+    let direction = null;
+    for (const properties of propertySources){
+        const bidi = directChild(properties, 'bidi');
+        if (bidi) direction = onOffValue(bidi) ? 'rtl' : 'ltr';
+    }
+    return direction;
+}
+function onOffValue(element) {
+    const value = (attribute(element, 'val') ?? attribute(element, 'w:val'))?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function work_docx_paragraph_direction_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_direction_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_direction_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_direction_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function 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) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
+    return block instanceof HTMLElement ? block : null;
+}
+function work_docx_paragraph_direction_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_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) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles);
+        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);
+        paragraphs.push({
+            marker,
+            alignment
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+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 ? work_docx_paragraph_alignment_import_closestParagraphBlock(node.parentElement, node) : null;
+        if (block && alignment) block.style.textAlign = alignment;
+        return '';
+    });
+    document.body.normalize();
+}
+function hasImportedDocxParagraphAlignmentMarkers(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 work_docx_paragraph_alignment_import_wordAttribute(element, name) {
+    return attribute(element, name) ?? attribute(element, `w:${name}`);
+}
+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 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;
+}
+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 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 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_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_indent_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_indent_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const TWIPS_PER_CSS_PIXEL = 15;
+const PARAGRAPH_INDENT_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_INDENT_\d+__/g;
+function markDocxParagraphIndents(document, styleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles);
+        if (sources.some((source)=>directChild(source, 'numPr'))) continue;
+        const indent = paragraphIndent(sources);
+        if (!indent.left && !indent.right && !indent.firstLine) continue;
+        properties ??= work_docx_paragraph_indent_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_INDENT_${paragraphs.length + 1}__`;
+        work_docx_paragraph_indent_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            indent
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphIndentMarkers(document, markers) {
+    const indentByMarker = new Map(markers.paragraphs.map(({ marker, indent })=>[
+            marker,
+            indent
+        ]));
+    for (const node of work_docx_paragraph_indent_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_INDENT_')) continue;
+        const block = work_docx_paragraph_indent_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_INDENT_MARKER_PATTERN, (marker)=>{
+            const indent = indentByMarker.get(marker);
+            if (block && indent) applyParagraphIndent(block, indent);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphIndentMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function paragraphIndent(propertySources) {
+    let left;
+    let right;
+    let firstLine;
+    for (const properties of propertySources){
+        const indent = directChild(properties, 'ind');
+        if (!indent) continue;
+        const sourceLeft = work_docx_paragraph_indent_import_numericAttribute(indent, 'start') ?? work_docx_paragraph_indent_import_numericAttribute(indent, 'left');
+        const sourceRight = work_docx_paragraph_indent_import_numericAttribute(indent, 'end') ?? work_docx_paragraph_indent_import_numericAttribute(indent, 'right');
+        const sourceFirstLine = work_docx_paragraph_indent_import_numericAttribute(indent, 'firstLine');
+        const sourceHanging = work_docx_paragraph_indent_import_numericAttribute(indent, 'hanging');
+        if (void 0 !== sourceLeft) left = sourceLeft;
+        if (void 0 !== sourceRight) right = sourceRight;
+        if (void 0 !== sourceFirstLine) firstLine = sourceFirstLine;
+        else if (void 0 !== sourceHanging) firstLine = -sourceHanging;
+    }
+    return normalizeDocumentParagraphIndent({
+        left: twipsToPixels(left),
+        right: twipsToPixels(right),
+        firstLine: twipsToPixels(firstLine)
+    });
+}
+function work_docx_paragraph_indent_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_indent_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_indent_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_indent_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_indent_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_indent_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_indent_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function applyParagraphIndent(element, value) {
+    const indent = normalizeDocumentParagraphIndent(value);
+    if (indent.left) {
+        element.dataset.officeIndentLevel = work_docx_paragraph_indent_import_formatNumber(indent.left / 24);
+        element.style.marginLeft = `${work_docx_paragraph_indent_import_formatNumber(indent.left)}px`;
+    }
+    if (indent.right) {
+        element.dataset.officeIndentRight = work_docx_paragraph_indent_import_formatNumber(indent.right);
+        element.style.marginRight = `${work_docx_paragraph_indent_import_formatNumber(indent.right)}px`;
+    }
+    if (indent.firstLine) {
+        element.dataset.officeIndentFirstLine = work_docx_paragraph_indent_import_formatNumber(indent.firstLine);
+        element.style.textIndent = `${work_docx_paragraph_indent_import_formatNumber(indent.firstLine)}px`;
+    }
+}
+function work_docx_paragraph_indent_import_numericAttribute(element, name) {
+    const raw = attribute(element, name) ?? attribute(element, `w:${name}`);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function twipsToPixels(value) {
+    if (void 0 === value) return 0;
+    return Math.round(value / TWIPS_PER_CSS_PIXEL);
+}
+function work_docx_paragraph_indent_import_formatNumber(value) {
+    return Number(value.toFixed(2)).toString();
+}
+function work_docx_paragraph_indent_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_pagination_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_pagination_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_PAGINATION_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_PAGINATION_\d+__/g;
+function markDocxParagraphPagination(document, styleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        if (properties && directChild(properties, 'numPr')) continue;
+        const pagination = paragraphPagination(docxParagraphPropertySources(properties, styles));
+        if (!Object.keys(pagination).length) continue;
+        properties ??= work_docx_paragraph_pagination_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_PAGINATION_${paragraphs.length + 1}__`;
+        work_docx_paragraph_pagination_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            pagination
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphPaginationMarkers(document, markers) {
+    const paginationByMarker = new Map(markers.paragraphs.map(({ marker, pagination })=>[
+            marker,
+            pagination
+        ]));
+    for (const node of work_docx_paragraph_pagination_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_PAGINATION_')) continue;
+        const block = work_docx_paragraph_pagination_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_PAGINATION_MARKER_PATTERN, (marker)=>{
+            const pagination = paginationByMarker.get(marker);
+            if (block && pagination) applyParagraphPagination(block, pagination);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphPaginationMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function paragraphPagination(sources) {
+    const pagination = {};
+    for (const properties of sources){
+        const keepLines = directChild(properties, 'keepLines');
+        const keepWithNext = directChild(properties, 'keepNext');
+        const pageBreakBefore = directChild(properties, 'pageBreakBefore');
+        const widowControl = directChild(properties, 'widowControl');
+        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);
+    }
+    return pagination;
+}
+function work_docx_paragraph_pagination_import_onOffValue(element) {
+    const value = (attribute(element, 'val') ?? attribute(element, 'w:val'))?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function work_docx_paragraph_pagination_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_pagination_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_pagination_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_pagination_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_pagination_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_pagination_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_pagination_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function applyParagraphPagination(element, pagination) {
+    setBooleanAttribute(element, 'data-office-keep-lines', pagination.keepLines);
+    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);
+}
+function setBooleanAttribute(element, name, value) {
+    if (void 0 !== value) element.setAttribute(name, String(value));
+}
+function work_docx_paragraph_pagination_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_spacing_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_spacing_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_SPACING_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_SPACING_\d+__/g;
+function markDocxParagraphSpacing(document, styleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles);
+        if (sources.some((source)=>directChild(source, 'numPr'))) continue;
+        const spacing = paragraphSpacing(sources);
+        if (!Object.keys(spacing).length) continue;
+        properties ??= work_docx_paragraph_spacing_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_SPACING_${paragraphs.length + 1}__`;
+        work_docx_paragraph_spacing_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            spacing
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphSpacingMarkers(document, markers) {
+    const spacingByMarker = new Map(markers.paragraphs.map(({ marker, spacing })=>[
+            marker,
+            spacing
+        ]));
+    for (const node of work_docx_paragraph_spacing_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_SPACING_')) continue;
+        const block = work_docx_paragraph_spacing_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_SPACING_MARKER_PATTERN, (marker)=>{
+            const spacing = spacingByMarker.get(marker);
+            if (block && spacing) applyParagraphSpacing(block, spacing);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphSpacingMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function paragraphSpacing(propertySources) {
+    let before;
+    let after;
+    let line;
+    let lineRule;
+    for (const properties of propertySources){
+        const spacing = directChild(properties, 'spacing');
+        if (!spacing) continue;
+        const sourceBefore = work_docx_paragraph_spacing_import_numericAttribute(spacing, 'before');
+        const sourceAfter = work_docx_paragraph_spacing_import_numericAttribute(spacing, 'after');
+        const sourceLine = work_docx_paragraph_spacing_import_numericAttribute(spacing, 'line');
+        const sourceLineRule = normalizedLineRule(work_docx_paragraph_spacing_import_wordAttribute(spacing, 'lineRule'));
+        if (void 0 !== sourceBefore) before = sourceBefore;
+        if (void 0 !== sourceAfter) after = sourceAfter;
+        if (void 0 !== sourceLine) {
+            line = sourceLine;
+            lineRule = sourceLineRule ?? 'auto';
+        } else if (sourceLineRule) lineRule = sourceLineRule;
+    }
+    const result = {};
+    if (void 0 !== before) result.before = twipsToPoints(before);
+    if (void 0 !== after) result.after = twipsToPoints(after);
+    if (void 0 !== line) {
+        const rule = lineRule ?? 'auto';
+        result.lineHeight = 'auto' === rule ? work_docx_paragraph_spacing_import_formatNumber(line / 240) : `${work_docx_paragraph_spacing_import_formatNumber(line / 20)}pt`;
+        result.lineRule = rule;
+    }
+    return result;
+}
+function applyParagraphSpacing(element, spacing) {
+    if (void 0 !== spacing.before && null !== spacing.before) {
+        const value = work_docx_paragraph_spacing_import_formatNumber(spacing.before);
+        element.dataset.officeSpaceBefore = value;
+        element.style.marginTop = `${value}pt`;
+    }
+    if (void 0 !== spacing.after && null !== spacing.after) {
+        const value = work_docx_paragraph_spacing_import_formatNumber(spacing.after);
+        element.dataset.officeSpaceAfter = value;
+        element.style.marginBottom = `${value}pt`;
+    }
+    if (spacing.lineHeight) element.style.lineHeight = spacing.lineHeight;
+    if (spacing.lineRule) element.dataset.officeLineRule = spacing.lineRule;
+}
+function work_docx_paragraph_spacing_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_spacing_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_spacing_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_spacing_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function work_docx_paragraph_spacing_import_numericAttribute(element, name) {
+    const raw = work_docx_paragraph_spacing_import_wordAttribute(element, name);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function work_docx_paragraph_spacing_import_wordAttribute(element, name) {
+    return attribute(element, name) ?? attribute(element, `w:${name}`);
+}
+function normalizedLineRule(value) {
+    if ('auto' === value || 'atLeast' === value) return value;
+    if ('exact' === value || 'exactly' === value) return 'exact';
+}
+function twipsToPoints(value) {
+    return Number((value / 20).toFixed(2));
+}
+function work_docx_paragraph_spacing_import_formatNumber(value) {
+    return Number(value.toFixed(3)).toString();
+}
+function work_docx_paragraph_spacing_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;
+}
+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;
+function markDocxRunFormatting(document, styleSource, themeSource) {
+    const runs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const theme = resolveDocxThemeResolver(themeSource);
+    for (const run of descendants(document, 'r')){
+        const runText = directRunText(run);
+        if (!runText || runText.includes('__A3S_')) continue;
+        const paragraph = work_docx_run_formatting_import_closestAncestor(run, 'p');
+        if (!paragraph) continue;
+        const paragraphProperties = directChild(paragraph, 'pPr');
+        const runProperties = directChild(run, 'rPr');
+        const formatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, runProperties, styles), theme);
+        if (!Object.keys(formatting).length) continue;
+        const index = runs.length + 1;
+        const startMarker = `__A3S_WORK_RUN_START_${index}__`;
+        const endMarker = `__A3S_WORK_RUN_END_${index}__`;
+        insertRunMarkers(document, run, runProperties, startMarker, endMarker);
+        runs.push({
+            startMarker,
+            endMarker,
+            formatting
+        });
+    }
+    return {
+        runs
+    };
+}
+function applyImportedDocxRunFormattingMarkers(document, markers) {
+    const replacements = new Map();
+    for (const marker of markers.runs){
+        replacements.set(marker.startMarker, formattingSpanStart(document, marker.formatting));
+        replacements.set(marker.endMarker, '</span>');
+    }
+    document.body.innerHTML = document.body.innerHTML.replace(RUN_FORMATTING_MARKER_PATTERN, (marker)=>replacements.get(marker) ?? '');
+}
+function hasImportedDocxRunFormattingMarkers(markers) {
+    return markers.runs.length > 0;
+}
+function resolvedRunFormatting(propertySources, theme) {
+    const fonts = {};
+    let fontSize;
+    let color;
+    let backgroundColor;
+    for (const properties of propertySources){
+        const runFonts = directChild(properties, 'rFonts');
+        if (runFonts) {
+            assignFont(fonts, 'ascii', resolvedFont(runFonts, 'ascii', 'asciiTheme', theme));
+            assignFont(fonts, 'hAnsi', resolvedFont(runFonts, 'hAnsi', 'hAnsiTheme', theme));
+            assignFont(fonts, 'eastAsia', resolvedFont(runFonts, 'eastAsia', 'eastAsiaTheme', theme));
+            assignFont(fonts, 'complex', resolvedFont(runFonts, 'cs', 'cstheme', theme));
+        }
+        const size = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'sz'), 'val');
+        if (void 0 !== size && size > 0) fontSize = Math.min(512, size / 2);
+        const colorElement = directChild(properties, 'color');
+        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()}`;
+        }
+        const highlight = directChild(properties, 'highlight');
+        if (highlight) {
+            const value = work_docx_run_formatting_import_wordAttribute(highlight, 'val')?.trim().toLowerCase();
+            if (value) backgroundColor = wordHighlightColor(value);
+        } 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()}`;
+        }
+    }
+    const fontFamily = uniqueFonts([
+        fonts.eastAsia,
+        fonts.hAnsi,
+        fonts.ascii,
+        fonts.complex
+    ]);
+    return {
+        ...fontFamily ? {
+            fontFamily
+        } : {},
+        ...void 0 !== fontSize ? {
+            fontSize
+        } : {},
+        ...color ? {
+            color
+        } : {},
+        ...backgroundColor ? {
+            backgroundColor
+        } : {}
+    };
+}
+function insertRunMarkers(document, run, properties, startMarker, endMarker) {
+    const start = work_docx_run_formatting_import_markerText(document, startMarker);
+    const end = work_docx_run_formatting_import_markerText(document, endMarker);
+    run.insertBefore(start, properties?.nextSibling ?? run.firstChild);
+    run.append(end);
+}
+function work_docx_run_formatting_import_markerText(document, marker) {
+    const text = document.createElementNS(work_docx_run_formatting_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_run_formatting_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    return text;
+}
+function formattingSpanStart(document, formatting) {
+    const span = document.createElement('span');
+    if (formatting.fontFamily) span.style.fontFamily = formatting.fontFamily;
+    if (void 0 !== formatting.fontSize) span.style.fontSize = `${work_docx_run_formatting_import_formatNumber(formatting.fontSize)}pt`;
+    if (formatting.color) span.style.color = formatting.color;
+    if (formatting.backgroundColor) span.style.backgroundColor = formatting.backgroundColor;
+    const html = span.outerHTML;
+    return html.slice(0, html.indexOf('>') + 1);
+}
+function directRunText(run) {
+    return Array.from(run.children).filter((child)=>'t' === child.localName || 'delText' === child.localName).map((child)=>child.textContent ?? '').join('');
+}
+function work_docx_run_formatting_import_closestAncestor(element, localName) {
+    let current = element.parentElement;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function assignFont(fonts, key, value) {
+    const normalized = value?.trim();
+    if (normalized) fonts[key] = normalized;
+}
+function resolvedFont(element, explicitName, themeName, theme) {
+    const explicit = work_docx_run_formatting_import_wordAttribute(element, explicitName);
+    if (explicit?.trim()) return explicit;
+    return docxThemeFont(theme, work_docx_run_formatting_import_wordAttribute(element, themeName)) ?? null;
+}
+function uniqueFonts(values) {
+    const fonts = [
+        ...new Set(values.filter((value)=>!!value))
+    ];
+    return fonts.length ? fonts.map(cssFontFamily).join(', ') : void 0;
+}
+function cssFontFamily(value) {
+    return /[\s"',]/.test(value) ? `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"` : value;
+}
+function work_docx_run_formatting_import_numericAttribute(element, name) {
+    if (!element) return;
+    const raw = work_docx_run_formatting_import_wordAttribute(element, name);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function work_docx_run_formatting_import_wordAttribute(element, name) {
+    return attribute(element, name) ?? attribute(element, `w:${name}`);
+}
+function wordHighlightColor(value) {
+    const colors = {
+        black: '#000000',
+        blue: '#0000ff',
+        cyan: '#00ffff',
+        darkblue: '#000080',
+        darkcyan: '#008080',
+        darkgray: '#808080',
+        darkgreen: '#008000',
+        darkmagenta: '#800080',
+        darkred: '#800000',
+        darkyellow: '#808000',
+        green: '#00ff00',
+        lightgray: '#c0c0c0',
+        magenta: '#ff00ff',
+        none: 'transparent',
+        red: '#ff0000',
+        white: '#ffffff',
+        yellow: '#ffff00'
+    };
+    return colors[value] ?? 'transparent';
+}
+function work_docx_run_formatting_import_formatNumber(value) {
+    return Number(value.toFixed(2)).toString();
+}
+const work_docx_tab_stop_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_tab_stop_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const work_docx_tab_stop_import_TWIPS_PER_CSS_PIXEL = 15;
+const PARAGRAPH_TAB_STOP_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_TAB_STOPS_\d+__/g;
+const INLINE_TAB_MARKER_PATTERN = /__A3S_WORK_INLINE_TAB_\d+__/g;
+function markDocxParagraphTabStops(document, styleSource) {
+    const paragraphs = [];
+    const inlineTabs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const tabStops = resolvedParagraphTabStops(docxParagraphPropertySources(properties, styles));
+        if (tabStops.length) {
+            properties ??= work_docx_tab_stop_import_insertParagraphProperties(document, paragraph);
+            const marker = `__A3S_WORK_PARAGRAPH_TAB_STOPS_${paragraphs.length + 1}__`;
+            work_docx_tab_stop_import_insertParagraphMarker(document, paragraph, properties, marker);
+            paragraphs.push({
+                marker,
+                tabStops
+            });
+        }
+        for (const tab of inlineRunTabs(paragraph)){
+            const marker = `__A3S_WORK_INLINE_TAB_${inlineTabs.length + 1}__`;
+            const text = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:t');
+            text.setAttributeNS(work_docx_tab_stop_import_XML_NAMESPACE, 'xml:space', 'preserve');
+            text.textContent = marker;
+            tab.replaceWith(text);
+            inlineTabs.push(marker);
+        }
+    }
+    return {
+        paragraphs,
+        inlineTabs
+    };
+}
+function applyImportedDocxParagraphTabStopMarkers(document, markers) {
+    const tabStopsByMarker = new Map(markers.paragraphs.map(({ marker, tabStops })=>[
+            marker,
+            tabStops
+        ]));
+    for (const node of work_docx_tab_stop_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_TAB_STOPS_')) continue;
+        const block = work_docx_tab_stop_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_TAB_STOP_MARKER_PATTERN, (marker)=>{
+            const tabStops = tabStopsByMarker.get(marker);
+            if (block && tabStops?.length) block.dataset.officeTabStops = serializeDocumentTabStops(tabStops);
+            return '';
+        });
+    }
+    const inlineMarkers = new Set(markers.inlineTabs);
+    for (const node of work_docx_tab_stop_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_INLINE_TAB_')) replaceInlineTabMarkers(node, inlineMarkers);
+    document.body.normalize();
+}
+function hasImportedDocxParagraphTabStopMarkers(markers) {
+    return markers.paragraphs.length > 0 || markers.inlineTabs.length > 0;
+}
+function resolvedParagraphTabStops(sources) {
+    const byPosition = new Map();
+    for (const properties of sources){
+        const tabs = directChild(properties, 'tabs');
+        if (tabs) for (const tab of directChildren(tabs, 'tab')){
+            const positionTwips = work_docx_tab_stop_import_numericAttribute(tab, 'pos');
+            if (void 0 === positionTwips || positionTwips <= 0) continue;
+            const position = positionTwips / work_docx_tab_stop_import_TWIPS_PER_CSS_PIXEL;
+            const value = work_docx_tab_stop_import_wordAttribute(tab, 'val')?.trim();
+            if ('clear' === value || 'bar' === value) {
+                byPosition.delete(position);
+                continue;
+            }
+            byPosition.set(position, {
+                position,
+                alignment: docxTabAlignment(value),
+                leader: docxTabLeader(work_docx_tab_stop_import_wordAttribute(tab, 'leader'))
+            });
+        }
+    }
+    return normalizeDocumentTabStops(Array.from(byPosition.values()));
+}
+function inlineRunTabs(paragraph) {
+    return descendants(paragraph, 'tab').filter((tab)=>{
+        let parent = tab.parentElement;
+        while(parent && parent !== paragraph){
+            if ('tabs' === parent.localName) return false;
+            parent = parent.parentElement;
+        }
+        return parent === paragraph;
+    });
+}
+function replaceInlineTabMarkers(node, markers) {
+    const matches = Array.from(node.data.matchAll(INLINE_TAB_MARKER_PATTERN));
+    if (!matches.length) return;
+    const fragment = node.ownerDocument.createDocumentFragment();
+    let offset = 0;
+    for (const match of matches){
+        const marker = match[0];
+        const index = match.index ?? 0;
+        if (index > offset) fragment.append(node.data.slice(offset, index));
+        if (markers.has(marker)) {
+            const tab = node.ownerDocument.createElement('span');
+            tab.dataset.documentTab = 'true';
+            tab.className = 'work-document-tab';
+            tab.setAttribute('role', 'separator');
+            tab.setAttribute('aria-label', '制表符');
+            fragment.append(tab);
+        } else fragment.append(marker);
+        offset = index + marker.length;
+    }
+    if (offset < node.data.length) fragment.append(node.data.slice(offset));
+    node.replaceWith(fragment);
+}
+function work_docx_tab_stop_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_tab_stop_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_tab_stop_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_tab_stop_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function docxTabAlignment(value) {
+    if ('center' === value) return 'center';
+    if ('right' === value || 'end' === value) return 'right';
+    if ('decimal' === value || 'num' === value) return 'decimal';
+    return 'left';
+}
+function docxTabLeader(value) {
+    if ('dot' === value) return 'dot';
+    if ('hyphen' === value) return 'hyphen';
+    if ('underscore' === value || 'heavy' === value) return 'underscore';
+    if ('middleDot' === value) return 'middleDot';
+    return 'none';
+}
+function work_docx_tab_stop_import_numericAttribute(element, name) {
+    const raw = work_docx_tab_stop_import_wordAttribute(element, name);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function work_docx_tab_stop_import_wordAttribute(element, name) {
+    return attribute(element, name) ?? attribute(element, `w:${name}`);
+}
+function work_docx_tab_stop_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_table_cell_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_table_cell_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const TABLE_CELL_MARKER_PATTERN = /__A3S_WORK_TABLE_CELL_\d+__/g;
+function markDocxTableCells(document) {
+    const cells = [];
+    for (const cell of descendants(document, 'tc')){
+        const properties = directChild(cell, 'tcPr');
+        const shading = properties ? directChild(properties, 'shd') : void 0;
+        const verticalAlignment = properties ? directChild(properties, 'vAlign') : void 0;
+        const directBorders = properties ? uniformBorders(directChild(properties, 'tcBorders')) : null;
+        const border = directBorders ?? uniformTableBorders(cell);
+        const backgroundColor = ooxmlColor(attribute(shading ?? cell, 'fill'));
+        const verticalAlign = tableVerticalAlign(attribute(verticalAlignment ?? cell, 'val'));
+        if (!backgroundColor && !verticalAlign && !border) continue;
+        const 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
+            } : {},
+            ...verticalAlign ? {
+                verticalAlign
+            } : {},
+            ...border ? {
+                borderColor: border.color,
+                borderStyle: border.style,
+                borderWidth: border.width
+            } : {}
+        });
+    }
+    return {
+        cells
+    };
+}
+function applyImportedDocxTableCellMarkers(document, markers) {
+    const cellByMarker = new Map(markers.cells.map((cell)=>[
+            cell.marker,
+            cell
+        ]));
+    for (const node of work_docx_table_cell_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_TABLE_CELL_')) continue;
+        const cell = node.parentElement?.closest('td, th');
+        node.data = node.data.replace(TABLE_CELL_MARKER_PATTERN, (marker)=>{
+            const format = cellByMarker.get(marker);
+            if (cell instanceof HTMLElement && format) applyCellFormat(cell, format);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxTableCellMarkers(markers) {
+    return markers.cells.length > 0;
+}
+function applyCellFormat(cell, format) {
+    if (format.backgroundColor) {
+        cell.dataset.officeCellFill = format.backgroundColor;
+        cell.style.backgroundColor = format.backgroundColor;
+    }
+    if (format.verticalAlign) {
+        cell.dataset.officeCellVerticalAlign = format.verticalAlign;
+        cell.style.verticalAlign = format.verticalAlign;
+    }
+    if (format.borderColor && format.borderStyle && void 0 !== format.borderWidth) {
+        cell.dataset.officeCellBorderColor = format.borderColor;
+        cell.dataset.officeCellBorderStyle = format.borderStyle;
+        cell.dataset.officeCellBorderWidth = String(format.borderWidth);
+        cell.style.border = 'none' === format.borderStyle || 0 === format.borderWidth ? '0px none transparent' : `${format.borderWidth}px ${format.borderStyle} ${format.borderColor}`;
+    }
+}
+function uniformTableBorders(cell) {
+    const table = work_docx_table_cell_import_closestAncestor(cell, 'tbl');
+    const properties = table ? directChild(table, 'tblPr') : void 0;
+    return properties ? uniformBorders(directChild(properties, 'tblBorders'), true) : null;
+}
+function uniformBorders(borders, includeInside = false) {
+    if (!borders) return null;
+    const edgeNames = includeInside ? [
+        'top',
+        'right',
+        'bottom',
+        'left',
+        'insideH',
+        'insideV'
+    ] : [
+        'top',
+        'right',
+        'bottom',
+        'left'
+    ];
+    const edgeElements = new Map(directChildren(borders).map((edge)=>[
+            edge.localName,
+            edge
+        ]));
+    const formats = edgeNames.map((name)=>parseBorder(edgeElements.get(name)));
+    if (formats.some((format)=>!format)) return null;
+    const first = formats[0];
+    if (!first) return null;
+    return formats.every((format)=>format?.color === first.color && format.style === first.style && format.width === first.width) ? first : null;
+}
+function parseBorder(edge) {
+    if (!edge) return null;
+    const style = tableBorderStyle(attribute(edge, 'val'));
+    if (!style) return null;
+    if ('none' === style) return {
+        color: '#000000',
+        style,
+        width: 0
+    };
+    const color = ooxmlColor(attribute(edge, 'color')) ?? '#000000';
+    const size = Number(attribute(edge, 'sz'));
+    const width = Number.isFinite(size) && size > 0 ? size / 6 : 1;
+    return {
+        color,
+        style,
+        width: Math.max(0.5, Math.min(6, Math.round(2 * width) / 2))
+    };
+}
+function tableBorderStyle(value) {
+    const normalized = value?.trim();
+    if (!normalized) return null;
+    if ('nil' === normalized || 'none' === normalized) return 'none';
+    if ('double' === normalized || 'triple' === normalized) return 'double';
+    if ('dotted' === normalized) return 'dotted';
+    if (/dash|dotDash|dotDotDash/i.test(normalized)) return 'dashed';
+    return 'solid';
+}
+function tableVerticalAlign(value) {
+    if ('center' === value) return 'middle';
+    if ('top' === value || 'bottom' === value) return value;
+    return null;
+}
+function ooxmlColor(value) {
+    const normalized = value?.trim().replace(/^#/, '').toLowerCase();
+    if (!normalized || 'auto' === normalized) return null;
+    if (/^[0-9a-f]{3}$/.test(normalized)) return `#${normalized.split('').map((part)=>`${part}${part}`).join('')}`;
+    return /^[0-9a-f]{6}$/.test(normalized) ? `#${normalized}` : null;
+}
+function firstTableCellParagraph(document, cell) {
+    const existing = directChild(cell, 'p') ?? descendants(cell, 'p').find((paragraph)=>work_docx_table_cell_import_closestAncestor(paragraph, 'tc') === cell);
+    if (existing) return existing;
+    const paragraph = document.createElementNS(work_docx_table_cell_import_WORD_NAMESPACE, 'w:p');
+    cell.append(paragraph);
+    return paragraph;
+}
+function insertCellMarker(document, paragraph, marker) {
+    const run = document.createElementNS(work_docx_table_cell_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_table_cell_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_table_cell_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 work_docx_table_cell_import_closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function work_docx_table_cell_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_table_row_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_table_row_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const TABLE_ROW_MARKER_PATTERN = /__A3S_WORK_TABLE_ROW_\d+__/g;
+const PIXELS_PER_TWIP = 96 / 1440;
+function markDocxTableRows(document) {
+    const rows = [];
+    for (const row of descendants(document, 'tr')){
+        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 paragraph = firstTableRowParagraph(document, row);
+        if (!paragraph) continue;
+        const marker = `__A3S_WORK_TABLE_ROW_${rows.length + 1}__`;
+        insertRowMarker(document, paragraph, marker);
+        rows.push({
+            marker,
+            ...cantSplit ? {
+                cantSplit: work_docx_table_row_import_onOffValue(cantSplit)
+            } : {},
+            ...repeatHeader ? {
+                repeatHeader: work_docx_table_row_import_onOffValue(repeatHeader)
+            } : {},
+            ...null !== rowHeight ? {
+                rowHeight
+            } : {},
+            ...null !== rowHeight && rowHeightRule ? {
+                rowHeightRule
+            } : {}
+        });
+    }
+    return {
+        rows
+    };
+}
+function applyImportedDocxTableRowMarkers(document, markers) {
+    const rowByMarker = new Map(markers.rows.map((row)=>[
+            row.marker,
+            row
+        ]));
+    for (const node of work_docx_table_row_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_TABLE_ROW_')) continue;
+        const row = node.parentElement?.closest('tr');
+        node.data = node.data.replace(TABLE_ROW_MARKER_PATTERN, (marker)=>{
+            const properties = rowByMarker.get(marker);
+            if (row instanceof HTMLTableRowElement && 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) {
+                    row.dataset.officeRowHeight = String(properties.rowHeight);
+                    row.style.height = `${properties.rowHeight}px`;
+                    row.dataset.officeRowHeightRule = properties.rowHeightRule ?? 'atLeast';
+                }
+            }
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxTableRowMarkers(markers) {
+    return markers.rows.length > 0;
+}
+function firstTableRowParagraph(document, row) {
+    const cell = directChild(row, 'tc');
+    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');
+    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');
+    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 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;
+}
+function work_docx_table_row_import_setBooleanAttribute(element, name, value) {
+    if (void 0 !== value) element.setAttribute(name, String(value));
+}
+function tableRowHeightRule(value) {
+    if ('exact' === value) return 'exact';
+    return 'atLeast' === value ? 'atLeast' : null;
+}
+function work_docx_table_row_import_twipsToPixels(value) {
+    if (!Number.isFinite(value) || value <= 0) return null;
+    return Math.round(value * PIXELS_PER_TWIP * 100) / 100;
+}
+function work_docx_table_row_import_closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function work_docx_table_row_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_table_sizing_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_table_sizing_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const TABLE_SIZING_MARKER_PATTERN = /__A3S_WORK_TABLE_SIZING_\d+__/g;
+const work_docx_table_sizing_import_PIXELS_PER_TWIP = 96 / 1440;
+function markDocxTableSizing(document) {
+    const tables = [];
+    for (const table of descendants(document, 'tbl')){
+        const paragraph = firstTableParagraph(document, table);
+        if (!paragraph) continue;
+        const properties = directChild(table, 'tblPr');
+        const layout = properties ? directChild(properties, 'tblLayout') : void 0;
+        const preferredWidth = properties ? directChild(properties, 'tblW') : void 0;
+        const grid = directChild(table, 'tblGrid');
+        const columnWidths = grid ? directChildren(grid, 'gridCol').map((column)=>work_docx_table_sizing_import_twipsToPixels(Number(attribute(column, 'w')))).filter((width)=>null !== width) : [];
+        const marker = `__A3S_WORK_TABLE_SIZING_${tables.length + 1}__`;
+        insertMarker(document, paragraph, marker);
+        tables.push({
+            marker,
+            layoutMode: importedTableLayoutMode(layout, preferredWidth),
+            columnWidths
+        });
+    }
+    return {
+        tables
+    };
+}
+function applyImportedDocxTableSizingMarkers(document, markers) {
+    const tableByMarker = new Map(markers.tables.map((table)=>[
+            table.marker,
+            table
+        ]));
+    for (const node of work_docx_table_sizing_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_TABLE_SIZING_')) continue;
+        const table = node.parentElement?.closest('table');
+        node.data = node.data.replace(TABLE_SIZING_MARKER_PATTERN, (marker)=>{
+            const sizing = tableByMarker.get(marker);
+            if (table instanceof HTMLTableElement && sizing) {
+                table.dataset.officeTableLayout = sizing.layoutMode;
+                if ('fixed' === sizing.layoutMode && sizing.columnWidths.length) applyColumnWidths(table, sizing.columnWidths);
+            }
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxTableSizingMarkers(markers) {
+    return markers.tables.length > 0;
+}
+function importedTableLayoutMode(layout, preferredWidth) {
+    const layoutType = layout ? attribute(layout, 'type') : null;
+    const widthType = preferredWidth ? attribute(preferredWidth, 'type') : null;
+    if ('autofit' === layoutType || 'auto' === widthType) return 'contents';
+    if ('pct' === widthType) return 'window';
+    return 'fixed';
+}
+function applyColumnWidths(table, columnWidths) {
+    const occupiedUntilRow = [];
+    Array.from(table.rows).forEach((row, rowIndex)=>{
+        let columnIndex = 0;
+        for (const cell of Array.from(row.cells)){
+            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(','));
+            if (cell.rowSpan > 1) for(let offset = 0; offset < cell.colSpan; offset += 1)occupiedUntilRow[columnIndex + offset] = rowIndex + cell.rowSpan;
+            columnIndex += cell.colSpan;
+        }
+    });
+}
+function firstTableParagraph(document, table) {
+    const cell = descendants(table, 'tc').find((candidate)=>work_docx_table_sizing_import_closestAncestor(candidate, 'tbl') === table);
+    if (!cell) return null;
+    const existing = descendants(cell, 'p').find((paragraph)=>work_docx_table_sizing_import_closestAncestor(paragraph, 'tc') === cell);
+    if (existing) return existing;
+    const paragraph = document.createElementNS(work_docx_table_sizing_import_WORD_NAMESPACE, 'w:p');
+    cell.append(paragraph);
+    return paragraph;
+}
+function insertMarker(document, paragraph, marker) {
+    const run = document.createElementNS(work_docx_table_sizing_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_table_sizing_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_table_sizing_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 work_docx_table_sizing_import_twipsToPixels(value) {
+    if (!Number.isFinite(value) || value <= 0) return null;
+    return Math.round(value * work_docx_table_sizing_import_PIXELS_PER_TWIP * 100) / 100;
+}
+function work_docx_table_sizing_import_closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function work_docx_table_sizing_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_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) {
+    const archive = await OoxmlPackage.load(buffer);
+    const bibliography = (await readDocxBibliography(archive)).bibliography;
+    const fallback = documentInitialSectionLayout({
+        type: 'document',
+        html: '<p></p>',
+        pageSize: 'a4'
+    });
+    if (!archive.has('word/document.xml')) return {
+        conversionBuffer: buffer,
+        sections: [
+            {
+                id: 'document-section-1',
+                layout: fallback
+            }
+        ],
+        captionMarkers: {
+            captions: [],
+            references: []
+        },
+        changeMarkers: {
+            changes: []
+        },
+        commentMarkers: {
+            comments: [],
+            ranges: []
+        },
+        fieldMarkers: {
+            fields: []
+        },
+        citationMarkers: {
+            citations: [],
+            bibliographies: []
+        },
+        listMarkers: {
+            lists: []
+        },
+        imageLayoutMarkers: {
+            images: []
+        },
+        paragraphAlignmentMarkers: {
+            paragraphs: []
+        },
+        paragraphDirectionMarkers: {
+            paragraphs: []
+        },
+        paragraphIndentMarkers: {
+            paragraphs: []
+        },
+        paragraphPaginationMarkers: {
+            paragraphs: []
+        },
+        paragraphSpacingMarkers: {
+            paragraphs: []
+        },
+        runFormattingMarkers: {
+            runs: []
+        },
+        tabStopMarkers: {
+            paragraphs: [],
+            inlineTabs: []
+        },
+        tableCellMarkers: {
+            cells: []
+        },
+        tableRowMarkers: {
+            rows: []
+        },
+        tableSizingMarkers: {
+            tables: []
+        },
+        bibliography,
+        trackChanges: false
+    };
+    const document = await archive.xml('word/document.xml');
+    const pageColor = importDocxPageColor(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 citationMarkers = markDocxCitationFields(document);
+    const fieldMarkers = markDocxBodyFields(document);
+    const listMarkers = markDocxLists(document, numbering);
+    const imageLayoutMarkers = markDocxImageLayouts(document);
+    const paragraphStylesDocument = archive.has('word/styles.xml') ? await archive.xml('word/styles.xml') : null;
+    const paragraphStyles = createDocxParagraphStyleResolver(paragraphStylesDocument);
+    const paragraphDirectionMarkers = markDocxParagraphDirections(document, paragraphStyles);
+    const paragraphAlignmentMarkers = markDocxParagraphAlignments(document, paragraphStyles);
+    const paragraphIndentMarkers = markDocxParagraphIndents(document, paragraphStyles);
+    const paragraphSpacingMarkers = markDocxParagraphSpacing(document, paragraphStyles);
+    const paragraphPaginationMarkers = markDocxParagraphPagination(document, paragraphStyles);
+    const themePath = archive.paths('word/theme/').find((path)=>/\/theme\d*\.xml$/i.test(path));
+    const themeDocument = themePath ? await archive.xml(themePath) : null;
+    const runFormattingMarkers = markDocxRunFormatting(document, paragraphStyles, themeDocument);
+    const tabStopMarkers = markDocxParagraphTabStops(document, paragraphStyles);
+    const tableCellMarkers = markDocxTableCells(document);
+    const tableRowMarkers = markDocxTableRows(document);
+    const tableSizingMarkers = markDocxTableSizing(document);
+    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,
+        sections: [
+            {
+                id: 'document-section-1',
+                layout: fallback
+            }
+        ],
+        pageColor,
+        captionMarkers,
+        changeMarkers,
+        commentMarkers,
+        fieldMarkers,
+        citationMarkers,
+        listMarkers,
+        imageLayoutMarkers,
+        paragraphAlignmentMarkers,
+        paragraphDirectionMarkers,
+        paragraphIndentMarkers,
+        paragraphPaginationMarkers,
+        paragraphSpacingMarkers,
+        runFormattingMarkers,
+        tabStopMarkers,
+        tableCellMarkers,
+        tableRowMarkers,
+        tableSizingMarkers,
+        bibliography,
+        trackChanges
+    };
+    const relationships = await archive.relationships('word/document.xml');
+    const oddEvenPageChrome = documentUsesOddEvenPageChrome(settings);
+    const sections = [];
+    let previous = fallback;
+    for (const [index, element] of sectionElements.entries()){
+        const layout = await parseSectionLayout(element, archive, relationships, previous, oddEvenPageChrome);
+        sections.push({
+            id: `document-section-${index + 1}`,
+            layout
+        });
+        previous = layout;
+    }
+    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,
+        sections,
+        pageColor,
+        captionMarkers,
+        changeMarkers,
+        commentMarkers,
+        fieldMarkers,
+        citationMarkers,
+        listMarkers,
+        imageLayoutMarkers,
+        paragraphAlignmentMarkers,
+        paragraphDirectionMarkers,
+        paragraphIndentMarkers,
+        paragraphPaginationMarkers,
+        paragraphSpacingMarkers,
+        runFormattingMarkers,
+        tabStopMarkers,
+        tableCellMarkers,
+        tableRowMarkers,
+        tableSizingMarkers,
+        bibliography,
+        trackChanges
+    };
+}
+function applyDocxSectionsToHtml(html, sections, captionMarkers = {
+    captions: [],
+    references: []
+}, changeMarkers = {
+    changes: []
+}, commentMarkers = {
+    comments: [],
+    ranges: []
+}, fieldMarkers = {
+    fields: []
+}, citationMarkers = {
+    citations: [],
+    bibliographies: []
+}, listMarkers = {
+    lists: []
+}, imageLayoutMarkers = {
+    images: []
+}, paragraphAlignmentMarkers = {
+    paragraphs: []
+}, runFormattingMarkers = {
+    runs: []
+}, paragraphDirectionMarkers = {
+    paragraphs: []
+}, paragraphIndentMarkers = {
+    paragraphs: []
+}, paragraphSpacingMarkers = {
+    paragraphs: []
+}, paragraphPaginationMarkers = {
+    paragraphs: []
+}, bibliography, tabStopMarkers = {
+    paragraphs: [],
+    inlineTabs: []
+}, tableCellMarkers = {
+    cells: []
+}, tableRowMarkers = {
+    rows: []
+}, tableSizingMarkers = {
+    tables: []
+}) {
+    const document = new DOMParser().parseFromString(html, 'text/html');
+    applyImportedDocxRunFormattingMarkers(document, runFormattingMarkers);
+    applyImportedDocxCaptionMarkers(document, captionMarkers);
+    applyImportedDocxCitationMarkers(document, citationMarkers);
+    applyImportedDocxFieldMarkers(document, fieldMarkers);
+    applyImportedDocxListMarkers(document, listMarkers);
+    applyImportedDocxImageLayoutMarkers(document, imageLayoutMarkers);
+    applyImportedDocxParagraphDirectionMarkers(document, paragraphDirectionMarkers);
+    applyImportedDocxParagraphIndentMarkers(document, paragraphIndentMarkers);
+    applyImportedDocxParagraphSpacingMarkers(document, paragraphSpacingMarkers);
+    applyImportedDocxParagraphPaginationMarkers(document, paragraphPaginationMarkers);
+    applyImportedDocxParagraphTabStopMarkers(document, tabStopMarkers);
+    applyImportedDocxParagraphAlignmentMarkers(document, paragraphAlignmentMarkers);
+    applyImportedDocxTableCellMarkers(document, tableCellMarkers);
+    applyImportedDocxTableSizingMarkers(document, tableSizingMarkers);
+    applyImportedDocxTableRowMarkers(document, tableRowMarkers);
+    applyImportedDocxChangeMarkers(document, changeMarkers);
+    applyImportedDocxCommentMarkers(document, commentMarkers);
+    const notes = extractMammothDocumentNotes(document);
+    const sourceNodes = Array.from(document.body.childNodes);
+    document.body.replaceChildren();
+    let sectionIndex = 0;
+    let section = createHtmlSection(document, sections[sectionIndex]);
+    for (const node of sourceNodes){
+        if (isSectionMarker(node, sectionIndex)) {
+            ensureSectionContent(section);
+            document.body.append(section);
+            sectionIndex += 1;
+            section = createHtmlSection(document, sections[sectionIndex] ?? sections.at(-1));
+            continue;
+        }
+        section.append(node);
+    }
+    ensureSectionContent(section);
+    document.body.append(section);
+    while(sectionIndex + 1 < sections.length){
+        sectionIndex += 1;
+        const missing = createHtmlSection(document, sections[sectionIndex]);
+        ensureSectionContent(missing);
+        document.body.append(missing);
+    }
+    placeMammothDocumentNotes(document, notes);
+    return normalizeDocumentCitationsHtml(normalizeDocumentFieldsHtml(normalizeDocumentCaptionsHtml(normalizeDocumentNotesHtml(document.body.innerHTML))), bibliography);
+}
+async function readDocxLayout(buffer) {
+    const prepared = await prepareDocxImport(buffer);
+    return {
+        ...documentContentLayoutProperties(prepared.sections[0].layout),
+        ...prepared.pageColor ? {
+            pageColor: prepared.pageColor
+        } : {}
+    };
+}
+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');
+    const columnsElement = firstDescendant(section, 'cols');
+    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
+        },
+        columns: columnsElement ? importDocxColumns(columnsElement, previous.columns) : {
+            ...previous.columns
+        },
+        breakAfter: parseSectionBreak(firstDescendant(section, 'type')),
+        ...pageChrome,
+        pageNumberStart: pageNumberStart > 0 ? pageNumberStart : void 0
+    };
+}
+function addSectionMarkers(document, sectionElements) {
+    for(let index = 0; index < sectionElements.length - 1; index += 1){
+        const paragraph = work_docx_import_closestAncestor(sectionElements[index], 'p');
+        if (!paragraph?.parentNode) continue;
+        const marker = document.createElementNS(work_docx_import_WORD_NAMESPACE, 'w:p');
+        const run = document.createElementNS(work_docx_import_WORD_NAMESPACE, 'w:r');
+        const text = document.createElementNS(work_docx_import_WORD_NAMESPACE, 'w:t');
+        text.setAttributeNS(work_docx_import_XML_NAMESPACE, 'xml:space', 'preserve');
+        text.textContent = sectionMarker(index);
+        run.append(text);
+        marker.append(run);
+        paragraph.parentNode.insertBefore(marker, paragraph.nextSibling);
+    }
+}
+async function writeDocumentXml(buffer, document) {
+    const zip = await jszip.loadAsync(buffer);
+    zip.file('word/document.xml', new XMLSerializer().serializeToString(document));
+    return zip.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function effectiveSectionProperties(document) {
+    return descendants(document, 'sectPr').filter((element)=>!work_docx_import_closestAncestor(element, 'sectPrChange'));
+}
+function createHtmlSection(document, section) {
+    const element = document.createElement('section');
+    const fallback = documentInitialSectionLayout({
+        type: 'document',
+        html: '<p></p>',
+        pageSize: 'a4'
+    });
+    const layout = section?.layout ?? fallback;
+    const id = section?.id ?? 'document-section';
+    for (const [name, value] of Object.entries(documentSectionDomAttributes(layout, id)))element.setAttribute(name, value);
+    return element;
+}
+function ensureSectionContent(section) {
+    if (!section.childNodes.length) section.innerHTML = '<p></p>';
+}
+function isSectionMarker(node, index) {
+    return node instanceof HTMLElement && node.textContent?.trim() === sectionMarker(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');
+    if ('continuous' === value || 'evenPage' === value || 'oddPage' === value || 'nextColumn' === value) return value;
+    return 'nextPage';
+}
+function work_docx_import_numberAttribute(element, name) {
+    if (!element) return 0;
+    const value = Number(attribute(element, name));
+    return Number.isFinite(value) ? value : 0;
+}
+function work_docx_import_closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    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 };