@a3s-lab/office 0.9.2 → 0.11.0

package/dist/{0~7754.js → 0~5093.js}

@@ -1,6 +1,6 @@
 import { descendants, directChildren as work_ooxml_package_directChildren, xmlNamespacePrefix, directChild, attribute as work_ooxml_package_attribute, childPath } from "./5184.js";
-import { xmlAttributeLocalName, docxThemeColor, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, xmlAttributeNamespace } from "./0~2805.js";
-import { DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentPageBorders, normalizeDocumentParagraphBorder, normalizeDocumentEquation, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, documentParagraphShadingDomAttributes, documentParagraphBordersDomAttributes, createDocumentEquationElement, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, documentEquationText, normalizeDocumentPaperSource } from "./8928.js";
+import { xmlAttributeLocalName, docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, xmlAttributeNamespace } from "./0~2805.js";
+import { DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentPageBorders, normalizeDocumentParagraphBorder, normalizeDocumentParagraphIndent, serializeDocumentParagraphFormatting, normalizeDocumentEquation, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentTabStops, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, documentWordLineHeightFactor, documentAutoLineHeight, renderDocumentAutoLineHeight, serializeDocxThemeReference, documentParagraphShadingDomAttributes, importedDocumentCharacterFormatting, documentParagraphBordersDomAttributes, createDocumentEquationElement, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, documentEquationText, normalizeDocumentPaperSource, serializeDocumentTabStops } from "./8928.js";
 function docxFieldInstructions(root) {
     return docxFieldOccurrences(root).map((field)=>field.instruction);
 }
@@ -4495,6 +4495,14 @@ function resolveDocxParagraphBordersForParagraph(paragraph, styleSource, themeSo
         spoofedCount: resolved.spoofedCount
     };
 }
+function resolveDocxParagraphBordersFromSources(propertySources, themeSource) {
+    const resolved = resolveParagraphBorderSources(propertySources, work_docx_theme_resolveDocxThemeResolver(themeSource));
+    return {
+        borders: work_document_paragraph_borders_normalizeDocumentParagraphBorders(resolved.borders),
+        invalidCount: resolved.invalidCount,
+        spoofedCount: resolved.spoofedCount
+    };
+}
 function applyImportedDocxParagraphBorderMarkers(document, markers) {
     const bordersByMarker = new Map(markers.paragraphs.map(({ marker, borders })=>[
             marker,
@@ -5476,6 +5484,9 @@ function parseDirectDocxParagraphShading(properties, themeSource) {
     const candidate = candidates[0];
     return candidate ? parseDocxParagraphShadingElement(candidate, themeSource) : void 0;
 }
+function resolveDocxParagraphShadingFromSources(propertySources, themeSource) {
+    return resolveParagraphShading(propertySources, work_docx_theme_resolveDocxThemeResolver(themeSource)).shading;
+}
 function resolveParagraphShading(propertySources, theme) {
     let shading = null;
     let specified = false;
@@ -5650,4 +5661,1439 @@ function work_docx_paragraph_shading_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphShadingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxParagraphPropertySources, docxRunPropertySources, docxTableCellStyleLayers, docxTableParagraphPropertySources, docxTablePropertySources, docxTableRunPropertySources, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphShadingMarkers, hasInvalidDocxFieldStructure, inspectDocxEquation, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, markDocxPackageEquations, markDocxParagraphBorders, markDocxParagraphShading, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxParagraphBordersForParagraph, resolveDocxParagraphStyleResolver, resolveDocxTableStyleResolver };
+const work_docx_paragraph_alignment_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_alignment_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_ALIGNMENT_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_ALIGNMENT_\d+__/g;
+function markDocxParagraphAlignments(document, styleSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        const alignment = resolveDocxParagraphAlignment(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 resolveDocxParagraphAlignment(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 work_ooxml_package_attribute(element, name) ?? work_ooxml_package_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() ? work_docx_paragraph_alignment_import_wrapListItemParagraph(block, markerNode) : block;
+}
+function work_docx_paragraph_alignment_import_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 && !work_docx_paragraph_alignment_import_isListItemBlock(children[start - 1]))start -= 1;
+    while(end + 1 < children.length && !work_docx_paragraph_alignment_import_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 work_docx_paragraph_alignment_import_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_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, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        const direction = resolveDocxParagraphDirection(sources);
+        if (!direction) continue;
+        properties ??= work_docx_paragraph_direction_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_DIRECTION_${paragraphs.length + 1}__`;
+        work_docx_paragraph_direction_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            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 = work_docx_paragraph_direction_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_DIRECTION_MARKER_PATTERN, (marker)=>{
+            const direction = directionByMarker.get(marker);
+            if (block && direction) block.setAttribute('dir', direction);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphDirectionMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function resolveDocxParagraphDirection(propertySources) {
+    let direction = null;
+    for (const properties of propertySources){
+        const bidi = directChild(properties, 'bidi');
+        if (bidi) direction = work_docx_paragraph_direction_import_onOffValue(bidi) ? 'rtl' : 'ltr';
+    }
+    return direction;
+}
+function work_docx_paragraph_direction_import_onOffValue(element) {
+    const value = (work_ooxml_package_attribute(element, 'val') ?? work_ooxml_package_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 work_docx_paragraph_direction_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_direction_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_direction_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
+    return block instanceof HTMLElement ? block : null;
+}
+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_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, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        if (sources.some((source)=>directChild(source, 'numPr'))) continue;
+        const indent = resolveDocxParagraphIndent(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 resolveDocxParagraphIndent(propertySources) {
+    let left;
+    let right;
+    let firstLine;
+    for (const properties of propertySources){
+        const indent = directChild(properties, 'ind');
+        if (!indent) continue;
+        const sourceLeft = numericAttribute(indent, 'start') ?? numericAttribute(indent, 'left');
+        const sourceRight = numericAttribute(indent, 'end') ?? numericAttribute(indent, 'right');
+        const sourceFirstLine = numericAttribute(indent, 'firstLine');
+        const sourceHanging = 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 = formatNumber(indent.left / 24);
+        element.style.marginLeft = `${formatNumber(indent.left)}px`;
+    }
+    if (indent.right) {
+        element.dataset.officeIndentRight = formatNumber(indent.right);
+        element.style.marginRight = `${formatNumber(indent.right)}px`;
+    }
+    if (indent.firstLine) {
+        element.dataset.officeIndentFirstLine = formatNumber(indent.firstLine);
+        element.style.textIndent = `${formatNumber(indent.firstLine)}px`;
+    }
+}
+function numericAttribute(element, name) {
+    const raw = work_ooxml_package_attribute(element, name) ?? work_ooxml_package_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 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, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        if (properties && directChild(properties, 'numPr')) continue;
+        const pagination = resolveDocxParagraphPagination(docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles)));
+        if (!Object.keys(pagination).length) continue;
+        properties ??= work_docx_paragraph_pagination_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_PAGINATION_${paragraphs.length + 1}__`;
+        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 resolveDocxParagraphPagination(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');
+        const contextualSpacing = directChild(properties, 'contextualSpacing');
+        const outlineLevel = directChild(properties, 'outlineLvl');
+        const defaultCollapsed = parseDocxParagraphDefaultCollapsed(properties);
+        if (keepLines) pagination.keepLines = work_docx_paragraph_pagination_import_onOffValue(keepLines);
+        if (keepWithNext) pagination.keepWithNext = work_docx_paragraph_pagination_import_onOffValue(keepWithNext);
+        if (pageBreakBefore) pagination.pageBreakBefore = work_docx_paragraph_pagination_import_onOffValue(pageBreakBefore);
+        if (widowControl) pagination.widowControl = work_docx_paragraph_pagination_import_onOffValue(widowControl);
+        if (contextualSpacing) pagination.contextualSpacing = work_docx_paragraph_pagination_import_onOffValue(contextualSpacing);
+        const outline = integerValue(outlineLevel);
+        if (null !== outline && outline <= 9) pagination.outlineLevel = outline;
+        if ('valid' === defaultCollapsed.status) pagination.defaultCollapsed = defaultCollapsed.value;
+        else if ('invalid' === defaultCollapsed.status) delete pagination.defaultCollapsed;
+    }
+    return pagination;
+}
+function work_docx_paragraph_pagination_import_onOffValue(element) {
+    const value = (work_ooxml_package_attribute(element, 'val') ?? work_ooxml_package_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);
+    setBooleanAttribute(element, 'data-office-contextual-spacing', pagination.contextualSpacing);
+    setBooleanAttribute(element, 'data-office-default-collapsed', pagination.defaultCollapsed);
+    if (void 0 !== pagination.outlineLevel) element.dataset.officeOutlineLevel = String(pagination.outlineLevel);
+}
+function integerValue(element) {
+    if (!element) return null;
+    const value = Number(work_ooxml_package_attribute(element, 'val') ?? work_ooxml_package_attribute(element, 'w:val'));
+    return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function setBooleanAttribute(element, name, value) {
+    if (void 0 !== value) element.setAttribute(name, String(value));
+}
+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, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        if (sources.some((source)=>directChild(source, 'numPr'))) continue;
+        const spacing = resolveDocxParagraphSpacing(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 resolveDocxParagraphSpacing(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;
+    if ('auto' === spacing.lineRule) {
+        const autoLineHeight = documentAutoLineHeight(spacing.lineHeight);
+        for (const [name, value] of Object.entries(renderDocumentAutoLineHeight(spacing.lineHeight, autoLineHeight)))if ('style' === name) for (const declaration of value.split(';')){
+            const separator = declaration.indexOf(':');
+            if (!(separator < 0)) element.style.setProperty(declaration.slice(0, separator).trim(), declaration.slice(separator + 1).trim());
+        }
+        else element.setAttribute(name, value);
+    }
+}
+function work_docx_paragraph_spacing_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:r');
+    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 work_ooxml_package_attribute(element, name) ?? work_ooxml_package_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;
+}
+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, tableStyleSource) {
+    const paragraphs = [];
+    const inlineTabs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const tabStops = resolveDocxParagraphTabStops(docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles)));
+        if (tabStops.length) {
+            properties ??= work_docx_tab_stop_import_insertParagraphProperties(document, paragraph);
+            const marker = `__A3S_WORK_PARAGRAPH_TAB_STOPS_${paragraphs.length + 1}__`;
+            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 resolveDocxParagraphTabStops(sources) {
+    const byPosition = new Map();
+    for (const properties of sources){
+        const tabs = directChild(properties, 'tabs');
+        if (tabs) for (const tab of work_ooxml_package_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 work_ooxml_package_attribute(element, name) ?? work_ooxml_package_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_paragraph_format_change_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const WORD_2012_NAMESPACE = 'http://schemas.microsoft.com/office/word/2012/wordml';
+const work_docx_paragraph_format_change_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const MAX_PARAGRAPH_FORMATTING_CHANGES = 65536;
+const PARAGRAPH_FORMATTING_CHANGE_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_FORMAT_CHANGE_\d+__/g;
+const SUPPORTED_PARAGRAPH_PROPERTY_CHANGE_CHILDREN = new Set([
+    'jc',
+    'bidi',
+    'ind',
+    'spacing',
+    'keepLines',
+    'keepNext',
+    'pageBreakBefore',
+    'widowControl',
+    'contextualSpacing',
+    'outlineLvl',
+    'tabs',
+    'pBdr',
+    'shd'
+]);
+function markDocxParagraphFormattingChanges(document, styleSource, themeSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const theme = work_docx_theme_resolveDocxThemeResolver(themeSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        if (!work_docx_paragraph_format_change_import_isWordElement(paragraph)) continue;
+        const propertyNodes = work_ooxml_package_directChildren(paragraph, 'pPr').filter((element)=>element.namespaceURI === paragraph.namespaceURI);
+        if (1 !== propertyNodes.length) continue;
+        const properties = propertyNodes[0];
+        if (!properties) continue;
+        const change = supportedParagraphFormattingChange(properties);
+        if (!change) continue;
+        if (paragraphs.length >= MAX_PARAGRAPH_FORMATTING_CHANGES) continue;
+        const sources = docxParagraphPropertySources(change.properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        const borders = resolveDocxParagraphBordersFromSources(sources, theme);
+        if (borders.invalidCount || borders.spoofedCount) continue;
+        const indent = resolveDocxParagraphIndent(sources);
+        const spacing = resolveDocxParagraphSpacing(sources);
+        const pagination = resolveDocxParagraphPagination(sources);
+        const tabStops = resolveDocxParagraphTabStops(sources);
+        const before = serializeDocumentParagraphFormatting({
+            textAlign: resolveDocxParagraphAlignment(sources),
+            paragraphDirection: resolveDocxParagraphDirection(sources),
+            indentLevel: indent.left / 24,
+            rightIndent: indent.right,
+            firstLineIndent: indent.firstLine,
+            spaceBefore: spacing.before ?? null,
+            spaceAfter: spacing.after ?? null,
+            lineHeight: spacing.lineHeight ?? null,
+            lineRule: spacing.lineRule ?? null,
+            autoLineHeight: 'auto' === spacing.lineRule ? documentAutoLineHeight(spacing.lineHeight) : null,
+            keepLines: pagination.keepLines ?? null,
+            keepWithNext: pagination.keepWithNext ?? null,
+            pageBreakBefore: pagination.pageBreakBefore ?? null,
+            widowControl: pagination.widowControl ?? null,
+            contextualSpacing: pagination.contextualSpacing ?? null,
+            outlineLevel: pagination.outlineLevel ?? null,
+            tabStops: tabStops.length ? tabStops : null,
+            paragraphBorders: borders.borders,
+            paragraphShading: resolveDocxParagraphShadingFromSources(sources, theme),
+            defaultCollapsed: pagination.defaultCollapsed ?? null
+        });
+        const marker = `__A3S_WORK_PARAGRAPH_FORMAT_CHANGE_${paragraphs.length + 1}__`;
+        work_docx_paragraph_format_change_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            id: `docx-paragraph-format-change-${change.id}`,
+            author: change.author,
+            date: normalizeRevisionDate(change.date),
+            before
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphFormattingChangeMarkers(document, markers) {
+    const changes = new Map(markers.paragraphs.map((change)=>[
+            change.marker,
+            change
+        ]));
+    for (const node of work_docx_paragraph_format_change_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_PARAGRAPH_FORMAT_CHANGE_')) node.data = node.data.replace(PARAGRAPH_FORMATTING_CHANGE_MARKER_PATTERN, (marker)=>{
+        const change = changes.get(marker);
+        const block = change ? work_docx_paragraph_format_change_import_closestParagraphBlock(node.parentElement, node) : null;
+        if (block && change) applyParagraphChange(block, change);
+        return '';
+    });
+    document.body.normalize();
+}
+function hasImportedDocxParagraphFormattingChangeMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function isSupportedDocxParagraphFormattingChange(change) {
+    const parent = change.parentElement;
+    const paragraph = parent?.parentElement;
+    return Boolean(parent?.localName === 'pPr' && DOCX_WORDPROCESSING_NAMESPACES.has(parent.namespaceURI ?? '') && paragraph?.localName === 'p' && DOCX_WORDPROCESSING_NAMESPACES.has(paragraph.namespaceURI ?? '') && 1 === Array.from(parent.children).filter((child)=>'pPrChange' === child.localName).length && supportedParagraphFormattingChangeElement(change));
+}
+function supportedParagraphFormattingChange(properties) {
+    const changes = Array.from(properties.children).filter((child)=>'pPrChange' === child.localName);
+    return 1 === changes.length ? supportedParagraphFormattingChangeElement(changes[0]) : null;
+}
+function supportedParagraphFormattingChangeElement(change) {
+    if ('pPrChange' !== change.localName || !DOCX_WORDPROCESSING_NAMESPACES.has(change.namespaceURI ?? '')) return null;
+    const propertyNodes = Array.from(change.children).filter((child)=>'pPr' === child.localName && DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? ''));
+    if (1 !== propertyNodes.length || 1 !== change.children.length) return null;
+    const properties = propertyNodes[0];
+    if (!properties) return null;
+    const names = new Set();
+    for (const child of Array.from(properties.children)){
+        const supportedWordChild = DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? '') && SUPPORTED_PARAGRAPH_PROPERTY_CHANGE_CHILDREN.has(child.localName);
+        const supportedCollapsed = 'collapsed' === child.localName && child.namespaceURI === WORD_2012_NAMESPACE;
+        if (!supportedWordChild && !supportedCollapsed || names.has(child.localName)) return null;
+        names.add(child.localName);
+    }
+    const id = work_ooxml_package_attribute(change, 'id')?.trim() ?? '';
+    const author = work_ooxml_package_attribute(change, 'author')?.trim() ?? '';
+    const date = work_ooxml_package_attribute(change, 'date');
+    if (!/^\+?\d{1,10}$/.test(id) || !author || author.length > 255) return null;
+    if (date && !Number.isFinite(Date.parse(date))) return null;
+    return {
+        id,
+        author,
+        date,
+        properties
+    };
+}
+function applyParagraphChange(element, change) {
+    element.dataset.documentChange = 'true';
+    element.dataset.changeKind = 'paragraph-formatting';
+    element.dataset.changeId = change.id;
+    element.dataset.changeAuthor = change.author;
+    element.dataset.changeDate = change.date;
+    element.dataset.changeBefore = change.before;
+}
+function work_docx_paragraph_format_change_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const namespace = paragraph.namespaceURI ?? work_docx_paragraph_format_change_import_WORD_NAMESPACE;
+    const prefix = paragraph.prefix || 'w';
+    const run = document.createElementNS(namespace, `${prefix}:r`);
+    const text = document.createElementNS(namespace, `${prefix}:t`);
+    text.setAttributeNS(work_docx_paragraph_format_change_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_format_change_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() ? work_docx_paragraph_format_change_import_wrapListItemParagraph(block, markerNode) : block;
+}
+function work_docx_paragraph_format_change_import_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 && !work_docx_paragraph_format_change_import_isListItemBlock(children[start - 1]))start -= 1;
+    while(end + 1 < children.length && !work_docx_paragraph_format_change_import_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 work_docx_paragraph_format_change_import_isListItemBlock(node) {
+    return node instanceof HTMLElement && [
+        'blockquote',
+        'div',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'hr',
+        'ol',
+        'p',
+        'pre',
+        'table',
+        'ul'
+    ].includes(node.tagName.toLowerCase());
+}
+function normalizeRevisionDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+function work_docx_paragraph_format_change_import_isWordElement(element) {
+    return DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '');
+}
+function work_docx_paragraph_format_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;
+}
+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;
+const SUPPORTED_RUN_PROPERTY_CHANGE_CHILDREN = new Set([
+    'b',
+    'bCs',
+    'i',
+    'iCs',
+    'u',
+    'strike',
+    'dstrike',
+    'rFonts',
+    'sz',
+    'szCs',
+    'color',
+    'highlight',
+    'shd',
+    'snapToGrid',
+    'cs',
+    'rtl',
+    'vertAlign'
+]);
+function markDocxRunFormatting(document, styleSource, themeSource, tableStyleSource) {
+    const runs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const theme = work_docx_theme_resolveDocxThemeResolver(themeSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    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, docxTableRunPropertySources(run, tableStyles)), theme, runText);
+        const change = importedRunFormattingChange(runProperties, paragraphProperties, styles, docxTableRunPropertySources(run, tableStyles), theme, runText);
+        if (!Object.keys(formatting).length && !change) 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,
+            ...change ? {
+                change
+            } : {}
+        });
+    }
+    return {
+        runs
+    };
+}
+function applyImportedDocxRunFormattingMarkers(document, markers) {
+    const replacements = new Map();
+    for (const marker of markers.runs){
+        const markup = formattingMarkup(document, marker.formatting);
+        const change = marker.change ? formattingChangeMarkup(document, marker.change) : {
+            start: '',
+            end: ''
+        };
+        replacements.set(marker.startMarker, `${change.start}${markup.start}`);
+        replacements.set(marker.endMarker, `${markup.end}${change.end}`);
+    }
+    document.body.innerHTML = document.body.innerHTML.replace(RUN_FORMATTING_MARKER_PATTERN, (marker)=>replacements.get(marker) ?? '');
+}
+function hasImportedDocxRunFormattingMarkers(markers) {
+    return markers.runs.length > 0;
+}
+function resolvedRunFormatting(propertySources, theme, runText) {
+    const fonts = {};
+    let fontSize;
+    let complexFontSize;
+    let color;
+    let backgroundColor;
+    let themeColor;
+    let themeFill;
+    let bold;
+    let complexBold;
+    let italic;
+    let complexItalic;
+    let underline;
+    let strike;
+    let subscript;
+    let superscript;
+    let snapToGrid;
+    let complexScriptFormatting;
+    let rightToLeft;
+    let fontHint;
+    for (const properties of propertySources){
+        bold = overriddenBoolean(bold, onOffProperty(properties, 'b'));
+        complexBold = overriddenBoolean(complexBold, onOffProperty(properties, 'bCs'));
+        italic = overriddenBoolean(italic, onOffProperty(properties, 'i'));
+        complexItalic = overriddenBoolean(complexItalic, onOffProperty(properties, 'iCs'));
+        underline = overriddenBoolean(underline, underlineProperty(properties));
+        strike = overriddenBoolean(strike, onOffProperty(properties, 'strike'));
+        strike = overriddenBoolean(strike, onOffProperty(properties, 'dstrike'));
+        const verticalAlign = directChild(properties, 'vertAlign');
+        if (verticalAlign) {
+            const value = work_docx_run_formatting_import_wordAttribute(verticalAlign, 'val')?.trim().toLowerCase();
+            subscript = "subscript" === value;
+            superscript = "superscript" === value;
+            if ('baseline' === value) {
+                subscript = false;
+                superscript = false;
+            }
+        }
+        snapToGrid = overriddenBoolean(snapToGrid, onOffProperty(properties, 'snapToGrid'));
+        complexScriptFormatting = overriddenBoolean(complexScriptFormatting, onOffProperty(properties, 'cs'));
+        rightToLeft = overriddenBoolean(rightToLeft, onOffProperty(properties, 'rtl'));
+        const runFonts = directChild(properties, 'rFonts');
+        if (runFonts) {
+            fontHint = resolvedFontHint(runFonts) ?? fontHint;
+            assignFont(fonts, 'ascii', resolvedFont(runFonts, 'ascii', 'asciiTheme', theme));
+            assignFont(fonts, 'hAnsi', resolvedFont(runFonts, 'hAnsi', 'hAnsiTheme', theme));
+            assignFont(fonts, 'eastAsia', resolvedFont(runFonts, 'eastAsia', 'eastAsiaTheme', theme));
+            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 complexSize = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'szCs'), 'val');
+        if (void 0 !== complexSize && complexSize > 0) complexFontSize = Math.min(512, complexSize / 2);
+        const colorElement = directChild(properties, 'color');
+        if (colorElement) {
+            const value = work_docx_run_formatting_import_wordAttribute(colorElement, 'val')?.trim();
+            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}`;
+                themeColor = work_docx_run_formatting_import_themeReference(colorElement, 'themeColor', 'themeTint', 'themeShade', color);
+            } else if (value?.toLowerCase() === 'auto') {
+                color = 'inherit';
+                themeColor = void 0;
+            } else if (value && /^[0-9a-f]{6}$/i.test(value)) {
+                color = `#${value.toLowerCase()}`;
+                themeColor = void 0;
+            }
+        }
+        const highlight = directChild(properties, 'highlight');
+        if (highlight) {
+            const value = work_docx_run_formatting_import_wordAttribute(highlight, 'val')?.trim().toLowerCase();
+            if (value) {
+                backgroundColor = wordHighlightColor(value);
+                themeFill = void 0;
+            }
+        } else {
+            const shading = directChild(properties, 'shd');
+            const fill = shading ? work_docx_run_formatting_import_wordAttribute(shading, 'fill')?.trim() : void 0;
+            const themed = shading ? docxThemeColor(theme, work_docx_run_formatting_import_wordAttribute(shading, 'themeFill'), work_docx_run_formatting_import_wordAttribute(shading, 'themeFillTint'), work_docx_run_formatting_import_wordAttribute(shading, 'themeFillShade')) : void 0;
+            if (themed) {
+                backgroundColor = `#${themed}`;
+                themeFill = work_docx_run_formatting_import_themeReference(shading, 'themeFill', 'themeFillTint', 'themeFillShade', backgroundColor);
+            } else if (fill?.toLowerCase() === 'auto') {
+                backgroundColor = 'transparent';
+                themeFill = void 0;
+            } else if (fill && /^[0-9a-f]{6}$/i.test(fill)) {
+                backgroundColor = `#${fill.toLowerCase()}`;
+                themeFill = void 0;
+            }
+        }
+    }
+    const fontSlot = true === complexScriptFormatting || true === rightToLeft ? 'complex' : docxFontSlotForText(runText, fontHint);
+    const usesComplexFormatting = 'complex' === fontSlot;
+    const resolvedBold = usesComplexFormatting ? complexBold ?? bold : bold;
+    const resolvedItalic = usesComplexFormatting ? complexItalic ?? italic : italic;
+    const resolvedFontSize = usesComplexFormatting ? complexFontSize ?? fontSize : fontSize;
+    let fontFamily = uniqueFonts(orderedFonts(fonts, fontSlot));
+    if (!fontFamily) fontFamily = uniqueFonts(orderedFonts({
+        ascii: docxThemeFont(theme, 'minorAscii'),
+        hAnsi: docxThemeFont(theme, 'minorHAnsi'),
+        eastAsia: docxThemeFont(theme, 'minorEastAsia'),
+        complex: docxThemeFont(theme, 'minorBidi')
+    }, fontSlot));
+    const hasRunPropertySource = propertySources.length > 0;
+    return {
+        ...void 0 !== resolvedBold || hasRunPropertySource ? {
+            bold: resolvedBold ?? false
+        } : {},
+        ...void 0 !== resolvedItalic || hasRunPropertySource ? {
+            italic: resolvedItalic ?? false
+        } : {},
+        ...void 0 !== underline || hasRunPropertySource ? {
+            underline: underline ?? false
+        } : {},
+        ...void 0 !== strike || hasRunPropertySource ? {
+            strike: strike ?? false
+        } : {},
+        ...void 0 !== subscript ? {
+            subscript
+        } : {},
+        ...void 0 !== superscript ? {
+            superscript
+        } : {},
+        ...fontFamily ? {
+            fontFamily,
+            wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
+        } : {},
+        ...void 0 !== resolvedFontSize ? {
+            fontSize: resolvedFontSize
+        } : {},
+        ...void 0 !== snapToGrid ? {
+            wordSnapToGrid: snapToGrid
+        } : {},
+        ...color ? {
+            color
+        } : {},
+        ...backgroundColor ? {
+            backgroundColor
+        } : {},
+        ...themeColor ? {
+            themeColor
+        } : {},
+        ...themeFill ? {
+            themeFill
+        } : {}
+    };
+}
+function insertRunMarkers(document, run, properties, startMarker, endMarker) {
+    const start = markerText(document, startMarker);
+    const end = markerText(document, endMarker);
+    run.insertBefore(start, properties?.nextSibling ?? run.firstChild);
+    run.append(end);
+}
+function 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 formattingMarkup(document, formatting) {
+    const span = document.createElement('span');
+    if (false === formatting.bold) span.style.fontWeight = 'normal';
+    if (false === formatting.italic) span.style.fontStyle = 'normal';
+    if ((false === formatting.underline || false === formatting.strike) && !formatting.underline && !formatting.strike) span.style.textDecorationLine = 'none';
+    if (formatting.fontFamily) span.style.fontFamily = formatting.fontFamily;
+    if (void 0 !== formatting.wordLineHeightFactor) {
+        const factor = formatLineHeightFactor(formatting.wordLineHeightFactor);
+        span.dataset.officeWordLineHeightFactor = factor;
+        span.style.setProperty('--work-document-word-line-height-factor', factor);
+    }
+    if (void 0 !== formatting.wordSnapToGrid) span.dataset.officeWordSnapToGrid = String(formatting.wordSnapToGrid);
+    if (void 0 !== formatting.fontSize) span.style.fontSize = `${work_docx_run_formatting_import_formatNumber(formatting.fontSize)}pt`;
+    if (formatting.color) span.style.color = formatting.color;
+    const themeColor = serializeDocxThemeReference(formatting.themeColor ?? null);
+    if (themeColor) span.dataset.officeThemeColor = themeColor;
+    if (formatting.backgroundColor) span.style.backgroundColor = formatting.backgroundColor;
+    const themeFill = serializeDocxThemeReference(formatting.themeFill ?? null);
+    if (themeFill) span.dataset.officeThemeFill = themeFill;
+    const html = span.outerHTML;
+    const tags = [
+        ...formatting.bold ? [
+            'strong'
+        ] : [],
+        ...formatting.italic ? [
+            'em'
+        ] : [],
+        ...formatting.underline ? [
+            'u'
+        ] : [],
+        ...formatting.strike ? [
+            's'
+        ] : [],
+        ...formatting.subscript ? [
+            'sub'
+        ] : [],
+        ...formatting.superscript ? [
+            'sup'
+        ] : []
+    ];
+    return {
+        start: `${html.slice(0, html.indexOf('>') + 1)}${tags.map((tag)=>`<${tag}>`).join('')}`,
+        end: `${[
+            ...tags
+        ].reverse().map((tag)=>`</${tag}>`).join('')}</span>`
+    };
+}
+function importedRunFormattingChange(runProperties, paragraphProperties, styles, contextualProperties, theme, runText) {
+    const parsed = supportedRunFormattingChange(runProperties);
+    if (!parsed) return;
+    const beforeFormatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, parsed.properties, styles, contextualProperties), theme, runText);
+    return {
+        id: `docx-format-change-${parsed.id}`,
+        author: parsed.author,
+        date: work_docx_run_formatting_import_normalizeRevisionDate(parsed.date),
+        before: importedDocumentCharacterFormatting({
+            ...beforeFormatting,
+            themeColor: serializeDocxThemeReference(beforeFormatting.themeColor ?? null),
+            themeFill: serializeDocxThemeReference(beforeFormatting.themeFill ?? null)
+        })
+    };
+}
+function isSupportedDocxRunFormattingChange(change) {
+    return Boolean(supportedRunFormattingChangeElement(change));
+}
+function supportedRunFormattingChange(runProperties) {
+    if (!runProperties) return null;
+    const changes = Array.from(runProperties.children).filter((child)=>'rPrChange' === child.localName);
+    return 1 === changes.length ? supportedRunFormattingChangeElement(changes[0]) : null;
+}
+function supportedRunFormattingChangeElement(change) {
+    if ('rPrChange' !== change.localName || !DOCX_WORDPROCESSING_NAMESPACES.has(change.namespaceURI ?? '')) return null;
+    const properties = Array.from(change.children).filter((child)=>'rPr' === child.localName && DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? ''));
+    if (1 !== properties.length || 1 !== change.children.length) return null;
+    const source = properties[0];
+    const names = new Set();
+    for (const child of Array.from(source.children)){
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? '') || !SUPPORTED_RUN_PROPERTY_CHANGE_CHILDREN.has(child.localName) || names.has(child.localName)) return null;
+        names.add(child.localName);
+    }
+    const id = work_ooxml_package_attribute(change, 'id')?.trim() ?? '';
+    const author = work_ooxml_package_attribute(change, 'author')?.trim() ?? '';
+    const date = work_ooxml_package_attribute(change, 'date');
+    if (!/^\+?\d{1,10}$/.test(id) || !author || author.length > 255) return null;
+    if (date && !Number.isFinite(Date.parse(date))) return null;
+    return {
+        id,
+        author,
+        date,
+        properties: source
+    };
+}
+function formattingChangeMarkup(document, change) {
+    const span = document.createElement('span');
+    span.dataset.documentChange = 'true';
+    span.dataset.changeKind = 'formatting';
+    span.dataset.changeId = change.id;
+    span.dataset.changeAuthor = change.author;
+    span.dataset.changeDate = change.date;
+    span.dataset.changeBefore = change.before;
+    const html = span.outerHTML;
+    return {
+        start: html.slice(0, html.indexOf('>') + 1),
+        end: '</span>'
+    };
+}
+function work_docx_run_formatting_import_normalizeRevisionDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+function work_docx_run_formatting_import_themeReference(element, themeName, tintName, shadeName, resolved) {
+    const theme = work_docx_run_formatting_import_wordAttribute(element, themeName)?.trim();
+    if (!theme) return;
+    const tint = normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, tintName));
+    const shade = normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, shadeName));
+    return {
+        theme,
+        resolved,
+        ...tint ? {
+            tint
+        } : {},
+        ...shade ? {
+            shade
+        } : {}
+    };
+}
+function normalizedByteHex(value) {
+    const normalized = value?.trim().toUpperCase();
+    return normalized && /^[0-9A-F]{2}$/.test(normalized) ? normalized : void 0;
+}
+function overriddenBoolean(current, next) {
+    return void 0 === next ? current : next;
+}
+function onOffProperty(properties, propertyName) {
+    const element = directChild(properties, propertyName);
+    if (!element) return;
+    const value = work_docx_run_formatting_import_wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function underlineProperty(properties) {
+    const element = directChild(properties, 'u');
+    if (!element) return;
+    const value = work_docx_run_formatting_import_wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value && 'none' !== value;
+}
+function directRunText(run) {
+    return Array.from(run.children).filter((child)=>'t' === child.localName || 'delText' === child.localName).map((child)=>child.textContent ?? '').join('');
+}
+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 resolvedFontHint(element) {
+    const hint = work_docx_run_formatting_import_wordAttribute(element, 'hint')?.trim().toLowerCase();
+    if ('eastasia' === hint) return 'eastAsia';
+    if ('cs' === hint) return 'complex';
+    if ('default' === hint) return 'ascii';
+}
+function orderedFonts(fonts, preferred) {
+    const order = {
+        ascii: [
+            'ascii',
+            'hAnsi',
+            'eastAsia',
+            'complex'
+        ],
+        hAnsi: [
+            'hAnsi',
+            'ascii',
+            'eastAsia',
+            'complex'
+        ],
+        eastAsia: [
+            'eastAsia',
+            'hAnsi',
+            'ascii',
+            'complex'
+        ],
+        complex: [
+            'complex',
+            'hAnsi',
+            'ascii',
+            'eastAsia'
+        ]
+    };
+    return order[preferred].map((slot)=>fonts[slot]);
+}
+function docxFontSlotForText(text, hint) {
+    for (const character of text){
+        const codePoint = character.codePointAt(0);
+        if (!(void 0 === codePoint || isNeutralCodePoint(codePoint))) {
+            if (isComplexScriptCodePoint(codePoint)) return 'complex';
+            if (isEastAsianCodePoint(codePoint)) return 'eastAsia';
+            return codePoint <= 0x7f ? 'ascii' : 'hAnsi';
+        }
+    }
+    return hint ?? 'ascii';
+}
+function isNeutralCodePoint(codePoint) {
+    return codePoint <= 0x20 || codePoint <= 0x7f && !(codePoint >= 0x41 && codePoint <= 0x5a || codePoint >= 0x61 && codePoint <= 0x7a) || codePoint >= 0x300 && codePoint <= 0x36f || codePoint >= 0x2000 && codePoint <= 0x206f;
+}
+function isComplexScriptCodePoint(codePoint) {
+    return codePoint >= 0x0590 && codePoint <= 0x08ff || codePoint >= 0xfb1d && codePoint <= 0xfdff || codePoint >= 0xfe70 && codePoint <= 0xfeff || codePoint >= 0x1ee00 && codePoint <= 0x1eeff;
+}
+function isEastAsianCodePoint(codePoint) {
+    return codePoint >= 0x1100 && codePoint <= 0x11ff || codePoint >= 0x2e80 && codePoint <= 0xa4cf || codePoint >= 0xac00 && codePoint <= 0xd7af || codePoint >= 0xf900 && codePoint <= 0xfaff || codePoint >= 0xfe10 && codePoint <= 0xfe6f || codePoint >= 0xff00 && codePoint <= 0xffef || codePoint >= 0x20000 && codePoint <= 0x323af;
+}
+function resolvedFont(element, explicitName, themeName, theme) {
+    const explicit = work_docx_run_formatting_import_wordAttribute(element, explicitName);
+    if (explicit?.trim()) return explicit;
+    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 work_ooxml_package_attribute(element, name) ?? work_ooxml_package_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();
+}
+function formatLineHeightFactor(value) {
+    return Number(value.toFixed(4)).toString();
+}
+export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxTableCellStyleLayers, docxTablePropertySources, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasInvalidDocxFieldStructure, inspectDocxEquation, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormatting, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxParagraphBordersForParagraph, resolveDocxTableStyleResolver };