@a3s-lab/office 0.2.2 → 0.4.0

package/dist/0~2805.js

@@ -0,0 +1,1279 @@
+import jszip from "jszip";
+import { serializeUtf8Xml, directChildren, xmlNamespacePrefix, parseXml, firstDescendant, decodeXmlBytes, directChild, descendants, attribute as work_ooxml_package_attribute } from "./5184.js";
+import { createDocumentBibliography, documentCitationStyle, documentCitationStyleDetails, normalizeDocumentTabStops } from "./8928.js";
+const BIBLIOGRAPHY_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/bibliography';
+const CUSTOM_XML_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/customXml';
+const OFFICE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const PACKAGE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const CONTENT_TYPES_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/content-types';
+const CUSTOM_XML_RELATIONSHIP = `${OFFICE_RELATIONSHIPS_NAMESPACE}/customXml`;
+const CUSTOM_XML_PROPS_RELATIONSHIP = `${OFFICE_RELATIONSHIPS_NAMESPACE}/customXmlProps`;
+const CUSTOM_XML_PROPS_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.customXmlProperties+xml';
+const COMMON_SOURCE_TYPES = new Set([
+    'Book',
+    'BookSection',
+    'JournalArticle',
+    'ArticleInAPeriodical',
+    'ConferenceProceedings',
+    'Report',
+    'InternetSite',
+    'DocumentFromInternetSite',
+    'ElectronicSource',
+    'Misc'
+]);
+const RESERVED_FIELDS = new Set([
+    'Tag',
+    'SourceType',
+    'Guid',
+    'Author',
+    'Title',
+    'Year',
+    'Publisher',
+    'City',
+    'JournalName',
+    'Volume',
+    'Issue',
+    'Pages',
+    'URL',
+    'StandardNumber',
+    'ConferenceName',
+    'Institution'
+]);
+async function readDocxBibliography(archive) {
+    const paths = archive.paths('customXml/').filter((path)=>/^customXml\/item(?!Props)[^/]*\.xml$/i.test(path));
+    const sources = [];
+    const usedTags = new Set();
+    const duplicateTags = new Set();
+    const uncommonSourceTypes = new Set();
+    let sourcePartCount = 0;
+    let unreadablePartCount = 0;
+    let selectedStyle = '';
+    let styleName = '';
+    for (const path of paths)try {
+        const document = await archive.xml(path);
+        if ('Sources' !== document.documentElement.localName || document.documentElement.namespaceURI !== BIBLIOGRAPHY_NAMESPACE) continue;
+        sourcePartCount += 1;
+        selectedStyle ||= work_ooxml_package_attribute(document.documentElement, 'SelectedStyle')?.trim() ?? '';
+        styleName ||= work_ooxml_package_attribute(document.documentElement, 'StyleName')?.trim() ?? '';
+        for (const element of directChildren(document.documentElement, 'Source')){
+            const source = parseCitationSource(element, sources.length + 1);
+            if (usedTags.has(source.tag)) {
+                duplicateTags.add(source.tag);
+                source.tag = uniqueSourceTag(source.tag, usedTags);
+            }
+            usedTags.add(source.tag);
+            if (!COMMON_SOURCE_TYPES.has(source.sourceType)) uncommonSourceTypes.add(source.sourceType);
+            sources.push(source);
+        }
+    } catch  {
+        unreadablePartCount += 1;
+    }
+    if (!sourcePartCount) return {
+        sourcePartCount,
+        unreadablePartCount,
+        duplicateTags: [],
+        uncommonSourceTypes: [],
+        uncommonStyle: void 0
+    };
+    const styleResult = bibliographyStyle(selectedStyle, styleName);
+    const style = styleResult.style;
+    return {
+        bibliography: {
+            ...createDocumentBibliography(style),
+            selectedStyle: selectedStyle || documentCitationStyleDetails(style).selectedStyle,
+            styleName: styleName || documentCitationStyleDetails(style).name,
+            sources
+        },
+        sourcePartCount,
+        unreadablePartCount,
+        duplicateTags: Array.from(duplicateTags),
+        uncommonSourceTypes: Array.from(uncommonSourceTypes),
+        uncommonStyle: styleResult.recognized ? void 0 : styleName || selectedStyle
+    };
+}
+async function patchDocxBibliography(buffer, bibliography) {
+    if (!bibliography?.sources.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const itemId = stableGuid(`bibliography:${bibliography.sources.map((source)=>source.tag).join('|')}`);
+    archive.file('customXml/item1.xml', serializeBibliographySources(bibliography));
+    archive.file('customXml/itemProps1.xml', serializeCustomXmlProperties(itemId));
+    archive.file('customXml/_rels/item1.xml.rels', serializeCustomXmlRelationships());
+    await upsertRelationship(archive, 'word/document.xml', CUSTOM_XML_RELATIONSHIP, '../customXml/item1.xml');
+    await upsertContentType(archive, '/customXml/itemProps1.xml', CUSTOM_XML_PROPS_CONTENT_TYPE);
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function parseCitationSource(element, index) {
+    const simple = new Map(directChildren(element).filter((child)=>!child.children.length).map((child)=>[
+            child.localName,
+            child.textContent?.trim() ?? ''
+        ]));
+    const tag = simple.get('Tag') || `Source${index}`;
+    const additionalFields = {};
+    for (const [name, value] of simple)if (!RESERVED_FIELDS.has(name) && value) additionalFields[name] = value;
+    return {
+        id: `docx-source-${safeIdPart(tag)}-${index}`,
+        tag,
+        sourceType: simple.get('SourceType') || 'Misc',
+        guid: simple.get('Guid') || void 0,
+        title: simple.get('Title') || '',
+        year: simple.get('Year') || void 0,
+        contributors: parseCitationContributors(directChild(element, 'Author')),
+        publisher: simple.get('Publisher') || void 0,
+        city: simple.get('City') || void 0,
+        journalName: simple.get('JournalName') || void 0,
+        volume: simple.get('Volume') || void 0,
+        issue: simple.get('Issue') || void 0,
+        pages: simple.get('Pages') || void 0,
+        url: simple.get('URL') || void 0,
+        standardNumber: simple.get('StandardNumber') || void 0,
+        conferenceName: simple.get('ConferenceName') || void 0,
+        institution: simple.get('Institution') || void 0,
+        additionalFields: Object.keys(additionalFields).length ? additionalFields : void 0
+    };
+}
+function parseCitationContributors(wrapper) {
+    if (!wrapper) return;
+    const roles = directChild(wrapper, 'NameList') || directChild(wrapper, 'Corporate') ? [
+        wrapper
+    ] : directChildren(wrapper);
+    const contributors = {};
+    for (const role of roles){
+        const nameList = directChild(role, 'NameList');
+        const people = nameList ? directChildren(nameList, 'Person').map(parseCitationPerson).filter(validCitationPerson) : [];
+        const corporate = directChild(role, 'Corporate')?.textContent?.trim();
+        if (people.length || corporate) contributors[role === wrapper ? 'Author' : role.localName] = {
+            people: people.length ? people : void 0,
+            corporate: corporate || void 0
+        };
+    }
+    return Object.keys(contributors).length ? contributors : void 0;
+}
+function parseCitationPerson(element) {
+    return {
+        first: directChild(element, 'First')?.textContent?.trim() ?? '',
+        middle: directChild(element, 'Middle')?.textContent?.trim() || void 0,
+        last: directChild(element, 'Last')?.textContent?.trim() ?? '',
+        suffix: directChild(element, 'Suffix')?.textContent?.trim() || void 0
+    };
+}
+function validCitationPerson(person) {
+    return Boolean(person.first || person.middle || person.last || person.suffix);
+}
+function serializeBibliographySources(bibliography) {
+    const styleDetails = documentCitationStyleDetails(bibliography.style);
+    const document = parseXml(`<b:Sources xmlns:b="${BIBLIOGRAPHY_NAMESPACE}" xmlns="${BIBLIOGRAPHY_NAMESPACE}"/>`, 'DOCX bibliography sources');
+    const root = document.documentElement;
+    root.setAttribute('SelectedStyle', bibliography.selectedStyle || styleDetails.selectedStyle);
+    root.setAttribute('StyleName', bibliography.styleName || styleDetails.name);
+    root.setAttribute('Version', '6');
+    for (const source of bibliography.sources){
+        const element = bibliographyElement(document, 'Source');
+        appendTextElement(document, element, 'Tag', source.tag);
+        appendTextElement(document, element, 'SourceType', source.sourceType || 'Misc');
+        appendTextElement(document, element, 'Guid', normalizeGuid(source.guid) || stableGuid(`source:${source.id}:${source.tag}`));
+        appendContributors(document, element, source.contributors);
+        appendTextElement(document, element, 'Title', source.title);
+        appendTextElement(document, element, 'Year', source.year);
+        appendTextElement(document, element, 'Publisher', source.publisher);
+        appendTextElement(document, element, 'City', source.city);
+        appendTextElement(document, element, 'JournalName', source.journalName);
+        appendTextElement(document, element, 'Volume', source.volume);
+        appendTextElement(document, element, 'Issue', source.issue);
+        appendTextElement(document, element, 'Pages', source.pages);
+        appendTextElement(document, element, 'URL', source.url);
+        appendTextElement(document, element, 'StandardNumber', source.standardNumber);
+        appendTextElement(document, element, 'ConferenceName', source.conferenceName);
+        appendTextElement(document, element, 'Institution', source.institution);
+        for (const [name, value] of Object.entries(source.additionalFields ?? {}).sort(([left], [right])=>left.localeCompare(right)))if (!RESERVED_FIELDS.has(name) && /^[A-Za-z_][A-Za-z0-9_.-]*$/.test(name)) appendTextElement(document, element, name, value);
+        root.append(element);
+    }
+    return new XMLSerializer().serializeToString(document);
+}
+function appendContributors(document, source, contributors) {
+    const entries = Object.entries(contributors ?? {}).filter(([, contributor])=>contributor.people?.length || contributor.corporate?.trim());
+    if (!entries.length) return;
+    const wrapper = bibliographyElement(document, 'Author');
+    for (const [roleName, contributor] of entries){
+        if (!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(roleName)) continue;
+        const role = bibliographyElement(document, roleName);
+        if (contributor.people?.length) {
+            const nameList = bibliographyElement(document, 'NameList');
+            for (const person of contributor.people){
+                const element = bibliographyElement(document, 'Person');
+                appendTextElement(document, element, 'Last', person.last);
+                appendTextElement(document, element, 'First', person.first);
+                appendTextElement(document, element, 'Middle', person.middle);
+                appendTextElement(document, element, 'Suffix', person.suffix);
+                nameList.append(element);
+            }
+            role.append(nameList);
+        } else if (contributor.corporate?.trim()) appendTextElement(document, role, 'Corporate', contributor.corporate);
+        wrapper.append(role);
+    }
+    if (wrapper.children.length) source.append(wrapper);
+}
+function appendTextElement(document, parent, name, value) {
+    if (!value?.trim()) return;
+    const element = bibliographyElement(document, name);
+    element.textContent = value.trim();
+    parent.append(element);
+}
+function bibliographyElement(document, name) {
+    return document.createElementNS(BIBLIOGRAPHY_NAMESPACE, `b:${name}`);
+}
+function serializeCustomXmlProperties(itemId) {
+    const document = parseXml(`<ds:datastoreItem xmlns:ds="${CUSTOM_XML_NAMESPACE}" ds:itemID="${itemId}"/>`, 'DOCX custom XML properties');
+    const references = document.createElementNS(CUSTOM_XML_NAMESPACE, 'ds:schemaRefs');
+    const reference = document.createElementNS(CUSTOM_XML_NAMESPACE, 'ds:schemaRef');
+    reference.setAttributeNS(CUSTOM_XML_NAMESPACE, 'ds:uri', BIBLIOGRAPHY_NAMESPACE);
+    references.append(reference);
+    document.documentElement.append(references);
+    return new XMLSerializer().serializeToString(document);
+}
+function serializeCustomXmlRelationships() {
+    return [
+        `<Relationships xmlns="${PACKAGE_RELATIONSHIPS_NAMESPACE}">`,
+        `<Relationship Id="rId1" Type="${CUSTOM_XML_PROPS_RELATIONSHIP}" Target="itemProps1.xml"/>`,
+        '</Relationships>'
+    ].join('');
+}
+async function upsertRelationship(archive, sourcePart, type, target) {
+    const path = relationshipPartPath(sourcePart);
+    const entry = archive.file(path);
+    const document = entry ? parseXml(await entry.async('text'), path) : parseXml(`<Relationships xmlns="${PACKAGE_RELATIONSHIPS_NAMESPACE}"/>`, path);
+    const root = document.documentElement;
+    const existing = directChildren(root, 'Relationship').find((item)=>work_ooxml_package_attribute(item, 'Type') === type);
+    if (existing) existing.setAttribute('Target', target);
+    else {
+        const relationship = document.createElementNS(PACKAGE_RELATIONSHIPS_NAMESPACE, 'Relationship');
+        relationship.setAttribute('Id', nextRelationshipId(root));
+        relationship.setAttribute('Type', type);
+        relationship.setAttribute('Target', target);
+        root.append(relationship);
+    }
+    archive.file(path, new XMLSerializer().serializeToString(document));
+}
+async function upsertContentType(archive, partName, contentType) {
+    const path = '[Content_Types].xml';
+    const entry = archive.file(path);
+    if (!entry) throw new Error('DOCX content types part is missing.');
+    const document = parseXml(await entry.async('text'), path);
+    const existing = directChildren(document.documentElement, 'Override').find((item)=>work_ooxml_package_attribute(item, 'PartName') === partName);
+    if (existing) existing.setAttribute('ContentType', contentType);
+    else {
+        const override = document.createElementNS(CONTENT_TYPES_NAMESPACE, 'Override');
+        override.setAttribute('PartName', partName);
+        override.setAttribute('ContentType', contentType);
+        document.documentElement.append(override);
+    }
+    archive.file(path, new XMLSerializer().serializeToString(document));
+}
+function bibliographyStyle(selectedStyle, styleName) {
+    const value = `${selectedStyle} ${styleName}`.toLowerCase();
+    if (value.includes('ieee')) return {
+        style: 'ieee',
+        recognized: true
+    };
+    if (value.includes('mla')) return {
+        style: 'mla',
+        recognized: true
+    };
+    if (value.includes('chicago')) return {
+        style: 'chicago',
+        recognized: true
+    };
+    if (!value.trim() || value.includes('apa')) return {
+        style: documentCitationStyle('apa'),
+        recognized: true
+    };
+    return {
+        style: documentCitationStyle('apa'),
+        recognized: false
+    };
+}
+function relationshipPartPath(sourcePart) {
+    const separator = sourcePart.lastIndexOf('/');
+    const directory = separator >= 0 ? sourcePart.slice(0, separator + 1) : '';
+    const fileName = separator >= 0 ? sourcePart.slice(separator + 1) : sourcePart;
+    return `${directory}_rels/${fileName}.rels`;
+}
+function nextRelationshipId(root) {
+    const used = new Set(directChildren(root, 'Relationship').map((item)=>work_ooxml_package_attribute(item, 'Id') ?? ''));
+    let index = 1;
+    while(used.has(`rId${index}`))index += 1;
+    return `rId${index}`;
+}
+function uniqueSourceTag(base, used) {
+    let index = 2;
+    while(used.has(`${base}_${index}`))index += 1;
+    return `${base}_${index}`;
+}
+function safeIdPart(value) {
+    return value.replace(/[^a-z0-9_-]/gi, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'source';
+}
+function normalizeGuid(value) {
+    const match = /^\{?([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\}?$/i.exec(value?.trim() ?? '');
+    return match ? `{${match[1].toUpperCase()}}` : '';
+}
+function stableGuid(source) {
+    const values = [
+        0,
+        1,
+        2,
+        3
+    ].map((salt)=>stableHash(`${salt}:${source}`));
+    const hex = values.join('').slice(0, 32).split('');
+    hex[12] = '4';
+    hex[16] = [
+        '8',
+        '9',
+        'A',
+        'B'
+    ][Number.parseInt(hex[16] ?? '0', 16) % 4];
+    const value = hex.join('').toUpperCase();
+    return `{${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}}`;
+}
+function stableHash(source) {
+    let hash = 2166136261;
+    for(let index = 0; index < source.length; index += 1){
+        hash ^= source.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+const XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const MARKUP_COMPATIBILITY_NAMESPACE = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+function declareInheritedNamespaces(importedRoot, sourceRoot) {
+    const mappings = new Map();
+    for (const element of [
+        sourceRoot,
+        ...Array.from(sourceRoot.querySelectorAll('*'))
+    ]){
+        if (element.prefix && element.namespaceURI && 'xml' !== element.prefix) {
+            if (!mappings.has(element.prefix)) mappings.set(element.prefix, element.namespaceURI);
+        }
+        for (const item of Array.from(element.attributes)){
+            const prefix = xmlAttributePrefix(item);
+            const namespace = xmlAttributeNamespace(element, item);
+            if (prefix && 'xmlns' !== prefix && 'xml' !== prefix && namespace && !mappings.has(prefix)) mappings.set(prefix, namespace);
+        }
+        if (element.namespaceURI === MARKUP_COMPATIBILITY_NAMESPACE && 'Choice' === element.localName) for (const prefix of (work_ooxml_package_attribute(element, 'Requires') ?? '').trim().split(/\s+/).filter(Boolean)){
+            const namespace = xmlNamespaceUri(element, prefix);
+            if (namespace && !mappings.has(prefix)) mappings.set(prefix, namespace);
+        }
+    }
+    for (const [prefix, namespace] of mappings)importedRoot.setAttributeNS(XMLNS_NAMESPACE, `xmlns:${prefix}`, namespace);
+}
+function collectRetainedNamespaces(root, retained) {
+    for (const element of [
+        root,
+        ...Array.from(root.querySelectorAll('*'))
+    ]){
+        if (element.namespaceURI) retained.add(element.namespaceURI);
+        for (const item of Array.from(element.attributes)){
+            const namespace = xmlAttributeNamespace(element, item);
+            if (namespace && namespace !== XMLNS_NAMESPACE) retained.add(namespace);
+        }
+    }
+}
+function cloneXmlElement(document, source) {
+    const namespace = source.namespaceURI;
+    const prefix = xmlNamespacePrefix(source, namespace);
+    const qualifiedName = prefix ? `${prefix}:${source.localName}` : source.localName;
+    const clone = document.createElementNS(namespace, qualifiedName);
+    for (const item of Array.from(source.attributes)){
+        const namespaceUri = xmlAttributeNamespace(source, item);
+        if (namespaceUri) clone.setAttributeNS(namespaceUri, item.name, item.value);
+        else clone.setAttribute(item.name, item.value);
+    }
+    for (const child of Array.from(source.childNodes))if (child instanceof Element) clone.append(cloneXmlElement(document, child));
+    else if (child.nodeType === Node.TEXT_NODE) clone.append(document.createTextNode(child.textContent ?? ''));
+    else if (child.nodeType === Node.CDATA_SECTION_NODE) clone.append(document.createCDATASection(child.textContent ?? ''));
+    else if (child.nodeType === Node.COMMENT_NODE) clone.append(document.createComment(child.textContent ?? ''));
+    return clone;
+}
+function xmlNamespaceUri(element, prefix) {
+    if ('xml' === prefix) return XML_NAMESPACE;
+    let current = element;
+    while(current){
+        if (current.prefix === prefix && current.namespaceURI) return current.namespaceURI;
+        const declaration = Array.from(current.attributes).find((item)=>isNamespaceDeclaration(item) && (prefix ? item.name === `xmlns:${prefix}` : 'xmlns' === item.name));
+        if (declaration) return declaration.value;
+        current = current.parentElement;
+    }
+    return null;
+}
+function xmlDeclaredPrefix(root, namespace) {
+    for (const item of Array.from(root.attributes))if (isNamespaceDeclaration(item) && item.value === namespace) return 'xmlns' === item.name ? null : item.name.slice(6);
+    return null;
+}
+function xmlAttributeNamespace(element, item) {
+    if (item.namespaceURI) return item.namespaceURI;
+    const prefix = xmlAttributePrefix(item);
+    return prefix ? xmlNamespaceUri(element, prefix) : null;
+}
+function xmlAttributePrefix(item) {
+    if (item.prefix) return item.prefix;
+    const separator = item.name.indexOf(':');
+    return separator > 0 ? item.name.slice(0, separator) : null;
+}
+function xmlAttributeLocalName(item) {
+    const separator = item.localName.indexOf(':');
+    return separator >= 0 ? item.localName.slice(separator + 1) : item.localName;
+}
+function hasXmlAttribute(element, namespace, localName) {
+    return Array.from(element.attributes).some((item)=>xmlAttributeNamespace(element, item) === namespace && xmlAttributeLocalName(item) === localName);
+}
+function hasUnexpectedXmlAttributes(element, allowedUnqualified) {
+    return Array.from(element.attributes).some((item)=>{
+        if (isNamespaceDeclaration(item)) return false;
+        return null !== xmlAttributeNamespace(element, item) || !allowedUnqualified.has(item.name);
+    });
+}
+function hasNonWhitespaceXmlText(element) {
+    return Array.from(element.childNodes).some((child)=>(child.nodeType === Node.TEXT_NODE || child.nodeType === Node.CDATA_SECTION_NODE) && Boolean(child.textContent?.trim()));
+}
+function isStructurallyValidAlternateContent(element) {
+    if (hasNonWhitespaceXmlText(element) || hasUnexpectedXmlAttributes(element, new Set())) return false;
+    const children = Array.from(element.children);
+    let choices = 0;
+    let fallbacks = 0;
+    let sawFallback = false;
+    for (const child of children){
+        if (child.namespaceURI !== MARKUP_COMPATIBILITY_NAMESPACE || 'Choice' !== child.localName && 'Fallback' !== child.localName) return false;
+        const allowedAttributes = 'Choice' === child.localName ? new Set([
+            'Requires'
+        ]) : new Set();
+        if (hasNonWhitespaceXmlText(child) || hasUnexpectedXmlAttributes(child, allowedAttributes)) return false;
+        if ('Fallback' === child.localName) {
+            fallbacks += 1;
+            sawFallback = true;
+            if (fallbacks > 1) return false;
+            continue;
+        }
+        if (sawFallback) return false;
+        choices += 1;
+        const required = (work_ooxml_package_attribute(child, 'Requires') ?? '').trim().split(/\s+/).filter(Boolean);
+        if (!required.length || required.some((prefix)=>!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(prefix) || !xmlNamespaceUri(child, prefix))) return false;
+    }
+    return choices > 0;
+}
+function assertXmlRoot(root, localName, namespaces, message) {
+    if (root.localName !== localName || !namespaces.has(root.namespaceURI ?? '')) throw new Error(message);
+}
+function isNamespaceDeclaration(attributeNode) {
+    return attributeNode.namespaceURI === XMLNS_NAMESPACE || 'xmlns' === attributeNode.name || attributeNode.name.startsWith('xmlns:');
+}
+const DOCX_WORDPROCESSING_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    'http://purl.oclc.org/ooxml/wordprocessingml/main'
+]);
+const work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+const RELATIONSHIP_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    'http://purl.oclc.org/ooxml/officeDocument/relationships'
+]);
+const MAX_EXTENSION_ELEMENTS = 4096;
+const MAX_EXTENSION_DEPTH = 64;
+function mergeDocxIgnorableExtensions(generatedDocument, sourceDocument, options = {}) {
+    mergeDocxIgnorableExtensionsAtPairs(generatedDocument, sourceDocument, [
+        {
+            generated: generatedDocument.documentElement,
+            source: sourceDocument.documentElement
+        }
+    ], options);
+}
+function mergeDocxIgnorableExtensionsAtPairs(generatedDocument, sourceDocument, pairs, options = {}) {
+    if (!pairs.length) return;
+    const sourceIgnorable = ignorableNamespaces(sourceDocument.documentElement);
+    const context = {
+        generatedDocument,
+        generatedRoot: generatedDocument.documentElement,
+        sourceRoot: sourceDocument.documentElement,
+        sourceIgnorable,
+        sourceIgnorableNamespaces: new Set(sourceIgnorable.map((item)=>item.namespace)),
+        retainedNamespaces: new Set(),
+        nextExtensionPrefix: 1,
+        options
+    };
+    for (const pair of pairs)mergeKnownElement(pair.generated, pair.source, context, 0);
+    mergeIgnorableNamespaces(context);
+    mergeCompatibilityQNameRules(context);
+}
+function mergeKnownElement(generated, source, context, depth) {
+    if (context.options.allowMatchedElementMerge && !context.options.allowMatchedElementMerge(generated, source, depth)) return;
+    mergePassiveAttributes(generated, source, context);
+    if (depth >= MAX_EXTENSION_DEPTH) return;
+    const generatedChildren = directChildren(generated);
+    const sourceChildren = directChildren(source);
+    const generatedGroups = groupChildren(generatedChildren, 'generated', context);
+    const sourceGroups = groupChildren(sourceChildren, 'source', context);
+    for (const sourceChild of sourceChildren){
+        const key = semanticElementKey(sourceChild, 'source', context);
+        const generatedMatches = generatedGroups.get(key) ?? [];
+        const sourceMatches = sourceGroups.get(key) ?? [];
+        if (1 === generatedMatches.length && 1 === sourceMatches.length) mergeKnownElement(generatedMatches[0], sourceChild, context, depth + 1);
+    }
+    const generatedSemanticNames = new Set(generatedChildren.filter((child)=>isWordprocessingNamespace(child.namespaceURI)).map((child)=>child.localName));
+    for (const [index, sourceChild] of sourceChildren.entries()){
+        const key = semanticElementKey(sourceChild, 'source', context);
+        if ((generatedGroups.get(key)?.length ?? 0) > 0) continue;
+        if (!isExtensionCandidate(sourceChild, context)) continue;
+        if (!isSafeExtensionSubtree(sourceChild, generatedSemanticNames, context)) continue;
+        const imported = cloneXmlElement(context.generatedDocument, sourceChild);
+        declareInheritedNamespaces(imported, sourceChild);
+        const anchor = followingGeneratedAnchor(sourceChildren, index, generatedGroups, sourceGroups, context);
+        generated.insertBefore(imported, anchor);
+        collectRetainedNamespaces(sourceChild, context.retainedNamespaces);
+    }
+}
+function mergePassiveAttributes(generated, source, context) {
+    for (const sourceAttribute of Array.from(source.attributes)){
+        const namespace = xmlAttributeNamespace(source, sourceAttribute);
+        const localName = xmlAttributeLocalName(sourceAttribute);
+        if (!namespace || namespace === XMLNS_NAMESPACE || namespace === XML_NAMESPACE || namespace === work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE || isWordprocessingNamespace(namespace) || RELATIONSHIP_NAMESPACES.has(namespace) || !context.sourceIgnorableNamespaces.has(namespace) || !isAllowedExtensionNamespace(namespace, context) || hasXmlAttribute(generated, namespace, localName)) continue;
+        const prefix = ensureRootNamespace(context, xmlAttributePrefix(sourceAttribute), namespace);
+        generated.setAttributeNS(namespace, `${prefix}:${localName}`, sourceAttribute.value);
+        context.retainedNamespaces.add(namespace);
+    }
+}
+function isExtensionCandidate(element, context) {
+    const namespace = element.namespaceURI;
+    if (!namespace || isWordprocessingNamespace(namespace)) return false;
+    if (namespace === work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE) return 'AlternateContent' === element.localName;
+    return namespace !== XMLNS_NAMESPACE && namespace !== XML_NAMESPACE && !RELATIONSHIP_NAMESPACES.has(namespace) && context.sourceIgnorableNamespaces.has(namespace) && isAllowedExtensionNamespace(namespace, context);
+}
+function isSafeExtensionSubtree(root, generatedSemanticNames, context) {
+    const stack = [
+        {
+            element: root,
+            depth: 1
+        }
+    ];
+    let elementCount = 0;
+    let alternateContentCount = 0;
+    while(stack.length){
+        const current = stack.pop();
+        if (!current) break;
+        elementCount += 1;
+        const namespace = current.element.namespaceURI;
+        if (elementCount > MAX_EXTENSION_ELEMENTS || current.depth > MAX_EXTENSION_DEPTH || RELATIONSHIP_NAMESPACES.has(namespace ?? '') || hasUnsafeExtensionAttribute(current.element, generatedSemanticNames, context)) return false;
+        if (isSemanticNamespace(namespace, context) && !context.options.allowSemanticElement?.(current.element, generatedSemanticNames)) return false;
+        if (namespace === work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE) {
+            if ('AlternateContent' === current.element.localName) {
+                alternateContentCount += 1;
+                if (alternateContentCount > 1 || !isStructurallyValidAlternateContent(current.element) || hasUnsafeAlternateContentRequirements(current.element, context)) return false;
+            } else if ('Choice' !== current.element.localName && 'Fallback' !== current.element.localName) return false;
+        }
+        for (const child of directChildren(current.element))stack.push({
+            element: child,
+            depth: current.depth + 1
+        });
+    }
+    return true;
+}
+function hasUnsafeExtensionAttribute(element, generatedSemanticNames, context) {
+    return Array.from(element.attributes).some((item)=>{
+        const namespace = xmlAttributeNamespace(element, item) ?? '';
+        if (!namespace || namespace === XMLNS_NAMESPACE || namespace === XML_NAMESPACE) return false;
+        if (RELATIONSHIP_NAMESPACES.has(namespace) || namespace === work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE) return true;
+        if (isSemanticNamespace(namespace, context)) return !(isSemanticNamespace(element.namespaceURI, context) && context.options.allowSemanticElement?.(element, generatedSemanticNames));
+        return !isAllowedExtensionNamespace(namespace, context);
+    });
+}
+function hasUnsafeAlternateContentRequirements(alternateContent, context) {
+    for (const choice of directChildren(alternateContent, 'Choice'))for (const prefix of (work_ooxml_package_attribute(choice, 'Requires') ?? '').trim().split(/\s+/).filter(Boolean)){
+        const namespace = xmlNamespaceUri(choice, prefix);
+        if (namespace && (isSemanticNamespace(namespace, context) || !isAllowedExtensionNamespace(namespace, context))) return true;
+    }
+    return false;
+}
+function followingGeneratedAnchor(sourceChildren, sourceIndex, generatedGroups, sourceGroups, context) {
+    for(let index = sourceIndex + 1; index < sourceChildren.length; index += 1){
+        const key = semanticElementKey(sourceChildren[index], 'source', context);
+        const generatedMatches = generatedGroups.get(key) ?? [];
+        if (1 === generatedMatches.length && (sourceGroups.get(key)?.length ?? 0) === 1) return generatedMatches[0];
+    }
+    return null;
+}
+function groupChildren(children, role, context) {
+    const groups = new Map();
+    for (const child of children){
+        const key = semanticElementKey(child, role, context);
+        const existing = groups.get(key);
+        if (existing) existing.push(child);
+        else groups.set(key, [
+            child
+        ]);
+    }
+    return groups;
+}
+function semanticElementKey(element, role, context) {
+    return context.options.semanticKey?.(element, role) ?? (isWordprocessingNamespace(element.namespaceURI) ? `word:${element.localName}` : `{${element.namespaceURI ?? ''}}${element.localName}`);
+}
+function ignorableNamespaces(root) {
+    const result = [];
+    const seen = new Set();
+    for (const prefix of (work_ooxml_package_attribute(root, 'mc:Ignorable') ?? '').trim().split(/\s+/).filter(Boolean)){
+        const namespace = xmlNamespaceUri(root, prefix);
+        if (!(!namespace || seen.has(namespace))) {
+            seen.add(namespace);
+            result.push({
+                prefix,
+                namespace
+            });
+        }
+    }
+    return result;
+}
+function mergeIgnorableNamespaces(context) {
+    const tokens = (work_ooxml_package_attribute(context.generatedRoot, 'mc:Ignorable') ?? '').trim().split(/\s+/).filter(Boolean);
+    const usedTokens = new Set(tokens);
+    const coveredNamespaces = new Set(tokens.flatMap((prefix)=>{
+        const namespace = xmlNamespaceUri(context.generatedRoot, prefix);
+        return namespace ? [
+            namespace
+        ] : [];
+    }));
+    let changed = false;
+    for (const item of context.sourceIgnorable){
+        if (!context.retainedNamespaces.has(item.namespace) || coveredNamespaces.has(item.namespace)) continue;
+        const prefix = ensureRootNamespace(context, item.prefix, item.namespace);
+        if (!usedTokens.has(prefix)) {
+            tokens.push(prefix);
+            usedTokens.add(prefix);
+            changed = true;
+        }
+        coveredNamespaces.add(item.namespace);
+    }
+    if (changed) setCompatibilityAttribute(context, 'Ignorable', tokens);
+}
+function mergeCompatibilityQNameRules(context) {
+    for (const name of [
+        'PreserveAttributes',
+        'PreserveElements',
+        'ProcessContent'
+    ]){
+        const tokens = (work_ooxml_package_attribute(context.generatedRoot, `mc:${name}`) ?? '').trim().split(/\s+/).filter(Boolean);
+        const used = new Set(tokens);
+        let changed = false;
+        for (const sourceToken of (work_ooxml_package_attribute(context.sourceRoot, `mc:${name}`) ?? '').trim().split(/\s+/).filter(Boolean)){
+            const match = /^([A-Za-z_][A-Za-z0-9_.-]*):([A-Za-z_][A-Za-z0-9_.-]*|\*)$/.exec(sourceToken);
+            const namespace = match ? xmlNamespaceUri(context.sourceRoot, match[1]) : null;
+            if (!match || !namespace || !context.retainedNamespaces.has(namespace)) continue;
+            const prefix = ensureRootNamespace(context, match[1], namespace);
+            const token = `${prefix}:${match[2]}`;
+            if (!used.has(token)) {
+                tokens.push(token);
+                changed = true;
+            }
+            used.add(token);
+        }
+        if (changed) setCompatibilityAttribute(context, name, tokens);
+    }
+}
+function setCompatibilityAttribute(context, localName, tokens) {
+    for (const item of Array.from(context.generatedRoot.attributes))if (xmlAttributeLocalName(item) === localName && (xmlAttributeNamespace(context.generatedRoot, item) === work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE || item.name === `mc:${localName}`)) context.generatedRoot.removeAttributeNode(item);
+    const prefix = ensureRootNamespace(context, 'mc', work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE);
+    context.generatedRoot.setAttributeNS(work_docx_ignorable_extension_preservation_MARKUP_COMPATIBILITY_NAMESPACE, `${prefix}:${localName}`, tokens.join(' '));
+}
+function ensureRootNamespace(context, preferredPrefix, namespace) {
+    const existing = xmlDeclaredPrefix(context.generatedRoot, namespace);
+    if (existing) return existing;
+    if (preferredPrefix && isNamespacePrefix(preferredPrefix) && !xmlNamespaceUri(context.generatedRoot, preferredPrefix)) {
+        context.generatedRoot.setAttributeNS(XMLNS_NAMESPACE, `xmlns:${preferredPrefix}`, namespace);
+        return preferredPrefix;
+    }
+    let prefix;
+    do {
+        prefix = `a3sExt${context.nextExtensionPrefix}`;
+        context.nextExtensionPrefix += 1;
+    }while (xmlNamespaceUri(context.generatedRoot, prefix))
+    context.generatedRoot.setAttributeNS(XMLNS_NAMESPACE, `xmlns:${prefix}`, namespace);
+    return prefix;
+}
+function isWordprocessingNamespace(namespace) {
+    return Boolean(namespace && DOCX_WORDPROCESSING_NAMESPACES.has(namespace));
+}
+function isSemanticNamespace(namespace, context) {
+    return Boolean(isWordprocessingNamespace(namespace) || namespace && context.options.isAdditionalSemanticNamespace?.(namespace));
+}
+function isAllowedExtensionNamespace(namespace, context) {
+    return context.options.allowExtensionNamespace?.(namespace) ?? true;
+}
+function isNamespacePrefix(value) {
+    return /^[A-Za-z_][A-Za-z0-9_.-]*$/.test(value) && 'xml' !== value;
+}
+const WORD_THEME_COLOR_KEYS = new Map([
+    [
+        'dark1',
+        'dk1'
+    ],
+    [
+        'light1',
+        'lt1'
+    ],
+    [
+        'dark2',
+        'dk2'
+    ],
+    [
+        'light2',
+        'lt2'
+    ],
+    [
+        'background1',
+        'lt1'
+    ],
+    [
+        'text1',
+        'dk1'
+    ],
+    [
+        'background2',
+        'lt2'
+    ],
+    [
+        'text2',
+        'dk2'
+    ],
+    [
+        'hyperlink',
+        'hlink'
+    ],
+    [
+        'followedhyperlink',
+        'folhlink'
+    ]
+]);
+const DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES = new Map([
+    [
+        'background1',
+        'bg1'
+    ],
+    [
+        'text1',
+        't1'
+    ],
+    [
+        'background2',
+        'bg2'
+    ],
+    [
+        'text2',
+        't2'
+    ],
+    [
+        'accent1',
+        'accent1'
+    ],
+    [
+        'accent2',
+        'accent2'
+    ],
+    [
+        'accent3',
+        'accent3'
+    ],
+    [
+        'accent4',
+        'accent4'
+    ],
+    [
+        'accent5',
+        'accent5'
+    ],
+    [
+        'accent6',
+        'accent6'
+    ],
+    [
+        'hyperlink',
+        'hyperlink'
+    ],
+    [
+        'followedhyperlink',
+        'followedHyperlink'
+    ]
+]);
+const WORD_COLOR_SCHEME_INDEXES = new Set([
+    'dark1',
+    'light1',
+    'dark2',
+    'light2',
+    'accent1',
+    'accent2',
+    'accent3',
+    'accent4',
+    'accent5',
+    'accent6',
+    'hyperlink',
+    'followedHyperlink'
+]);
+const WORDPROCESSING_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    'http://purl.oclc.org/ooxml/wordprocessingml/main'
+]);
+const MAX_COLOR_MAPPING_DEPTH = 16;
+function createDocxThemeResolver(themeDocument, settingsDocument) {
+    const colorMapping = docxColorSchemeMapping(settingsDocument);
+    if (!themeDocument) return {
+        colors: new Map(),
+        colorMapping,
+        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,
+        colorMapping,
+        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 sourceKey = key?.trim().toLowerCase();
+    const mappedKey = sourceKey ? mappedWordThemeColorKey(sourceKey, resolver.colorMapping) : void 0;
+    const colorKey = mappedKey ? WORD_THEME_COLOR_KEYS.get(mappedKey) ?? mappedKey : void 0;
+    const color = colorKey ? resolver.colors.get(colorKey) : 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 docxColorSchemeMapping(settingsDocument) {
+    const root = settingsDocument?.documentElement;
+    if (!root || 'settings' !== root.localName || !WORDPROCESSING_NAMESPACES.has(root.namespaceURI ?? '')) return new Map();
+    const candidates = directChildren(root, 'clrSchemeMapping').filter((element)=>element.namespaceURI === root.namespaceURI);
+    if (1 !== candidates.length) return new Map();
+    return parseDocxColorSchemeMappingElement(candidates[0]) ?? new Map();
+}
+function parseDocxColorSchemeMappingElement(element) {
+    const namespace = element?.namespaceURI ?? '';
+    if (!element || 'clrSchemeMapping' !== element.localName || !WORDPROCESSING_NAMESPACES.has(namespace) || directChildren(element).length || Array.from(element.childNodes).some((node)=>node.nodeType === Node.TEXT_NODE && node.textContent?.trim())) return null;
+    const semanticsByAttribute = new Map(Array.from(DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES).map(([semantic, attributeName])=>[
+            attributeName,
+            semantic
+        ]));
+    const mapping = new Map();
+    for (const item of Array.from(element.attributes)){
+        if (item.namespaceURI === XMLNS_NAMESPACE || 'xmlns' === item.name || item.name.startsWith('xmlns:')) continue;
+        const attributeName = xmlAttributeLocalName(item);
+        const semantic = semanticsByAttribute.get(attributeName);
+        const value = item.value.trim();
+        if (xmlAttributeNamespace(element, item) !== namespace || !semantic || mapping.has(semantic) || !WORD_COLOR_SCHEME_INDEXES.has(value)) return null;
+        mapping.set(semantic, value);
+    }
+    return mapping;
+}
+function mappedWordThemeColorKey(source, mapping) {
+    let current = source;
+    const visited = new Set();
+    for(let depth = 0; depth < MAX_COLOR_MAPPING_DEPTH; depth += 1){
+        if (visited.has(current)) break;
+        visited.add(current);
+        const next = mapping?.get(current)?.toLowerCase();
+        if (!next || next === current) return current;
+        current = next;
+    }
+}
+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 work_ooxml_package_attribute(element, name) ?? work_ooxml_package_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);
+}
+function paragraphAlignment(element, docx) {
+    const alignment = element.style.textAlign;
+    if ('center' === alignment) return docx.AlignmentType.CENTER;
+    if ('right' === alignment || 'end' === alignment) return docx.AlignmentType.RIGHT;
+    if ('justify' === alignment) return docx.AlignmentType.JUSTIFIED;
+    if ('left' === alignment || 'start' === alignment) return docx.AlignmentType.LEFT;
+}
+function paragraphDirectionOptions(element) {
+    const bidirectional = paragraphBidirectional(element);
+    return void 0 === bidirectional ? {} : {
+        bidirectional
+    };
+}
+function paragraphBidirectional(element) {
+    const direction = domDirection(element);
+    return void 0 === direction ? void 0 : 'rtl' === direction;
+}
+function domDirection(element) {
+    let current = element;
+    while(current){
+        const attribute = current.getAttribute('dir')?.trim().toLowerCase();
+        if ('ltr' === attribute || 'rtl' === attribute) return attribute;
+        if ('auto' === attribute) break;
+        const css = current.style.direction.trim().toLowerCase();
+        if ('ltr' === css || 'rtl' === css) return css;
+        current = current.parentElement;
+    }
+}
+function paragraphLineSpacing(element) {
+    const value = element.style.lineHeight.trim();
+    if (!value || 'normal' === value) return;
+    const percentage = /^(\d+(?:\.\d+)?)%$/.exec(value);
+    if (percentage) return Math.round(Number(percentage[1]) / 100 * 240);
+    const unitless = /^(\d+(?:\.\d+)?)$/.exec(value);
+    if (unitless) return Math.round(240 * Number(unitless[1]));
+    const points = cssLengthToPoints(value);
+    return points ? Math.round(20 * points) : void 0;
+}
+function paragraphSpacingOptions(element, heading, docx) {
+    const before = dataPointLengthToTwips(element.dataset.officeSpaceBefore) ?? cssSpacingLengthToTwips(element.style.marginTop);
+    const after = dataPointLengthToTwips(element.dataset.officeSpaceAfter) ?? cssSpacingLengthToTwips(element.style.marginBottom);
+    const lineRule = paragraphLineRule(element, docx);
+    return {
+        after: after ?? (heading ? 180 : 120),
+        ...void 0 !== before ? {
+            before
+        } : {},
+        line: paragraphLineSpacing(element) ?? 320,
+        ...lineRule ? {
+            lineRule
+        } : {}
+    };
+}
+function paragraphLineRule(element, docx) {
+    if ('auto' === element.dataset.officeLineRule) return docx.LineRuleType.AUTO;
+    if ('exact' === element.dataset.officeLineRule) return docx.LineRuleType.EXACT;
+    if ('atLeast' === element.dataset.officeLineRule) return docx.LineRuleType.AT_LEAST;
+}
+function paragraphIndent(element, tag) {
+    const blockquoteIndent = 'blockquote' === tag ? 540 : 0;
+    const level = Number(element.dataset.officeIndentLevel);
+    const explicitIndent = Number.isFinite(level) && level > 0 ? Math.round(360 * level) : cssLengthToTwips(element.style.marginLeft);
+    const left = blockquoteIndent + explicitIndent;
+    const right = dataPixelLengthToTwips(element.dataset.officeIndentRight) ?? cssLengthToTwips(element.style.marginRight);
+    const firstLine = dataPixelLengthToTwips(element.dataset.officeIndentFirstLine, true) ?? cssSignedLengthToTwips(element.style.textIndent);
+    if (!left && !right && !firstLine) return;
+    return {
+        ...left > 0 ? {
+            left
+        } : {},
+        ...right > 0 ? {
+            right
+        } : {},
+        ...firstLine > 0 ? {
+            firstLine
+        } : {},
+        ...firstLine < 0 ? {
+            hanging: Math.abs(firstLine)
+        } : {}
+    };
+}
+function paragraphPaginationOptions(element) {
+    const outlineLevel = Number(element.dataset.officeOutlineLevel);
+    return {
+        keepLines: dataBoolean(element.dataset.officeKeepLines),
+        keepNext: dataBoolean(element.dataset.officeKeepWithNext),
+        pageBreakBefore: dataBoolean(element.dataset.officePageBreakBefore),
+        widowControl: dataBoolean(element.dataset.officeWidowControl),
+        contextualSpacing: dataBoolean(element.dataset.officeContextualSpacing),
+        ...Number.isSafeInteger(outlineLevel) && outlineLevel >= 0 && outlineLevel <= 9 ? {
+            outlineLevel
+        } : {}
+    };
+}
+function paragraphTabStops(element, docx) {
+    const tabStops = normalizeDocumentTabStops(element.dataset.officeTabStops ?? '').map((tabStop)=>({
+            type: docxTabStopType(tabStop.alignment, docx),
+            position: Math.round(15 * tabStop.position),
+            ...'none' === tabStop.leader ? {} : {
+                leader: docxTabLeader(tabStop.leader, docx)
+            }
+        }));
+    return tabStops.length ? tabStops : void 0;
+}
+function docxTabStopType(alignment, docx) {
+    if ('center' === alignment) return docx.TabStopType.CENTER;
+    if ('right' === alignment) return docx.TabStopType.RIGHT;
+    if ('decimal' === alignment) return docx.TabStopType.DECIMAL;
+    return docx.TabStopType.LEFT;
+}
+function docxTabLeader(leader, docx) {
+    if ('dot' === leader) return docx.LeaderType.DOT;
+    if ('hyphen' === leader) return docx.LeaderType.HYPHEN;
+    if ('underscore' === leader) return docx.LeaderType.UNDERSCORE;
+    if ('middleDot' === leader) return docx.LeaderType.MIDDLE_DOT;
+    return docx.LeaderType.NONE;
+}
+function dataBoolean(value) {
+    if ('true' === value || '1' === value) return true;
+    if ('false' === value || '0' === value) return false;
+}
+function cssFontFamily(value) {
+    const family = value.split(',')[0]?.trim().replace(/^(['"])(.*)\1$/, '$2');
+    return family || void 0;
+}
+function cssFontSize(value) {
+    const points = cssLengthToPoints(value);
+    return points ? Math.max(1, Math.round(2 * points)) : void 0;
+}
+function cssLengthToTwips(value) {
+    const points = cssLengthToPoints(value);
+    return points ? Math.max(0, Math.round(20 * points)) : 0;
+}
+function cssSignedLengthToTwips(value) {
+    const match = /^(-?\d+(?:\.\d+)?)(px|pt|in|cm|mm)$/i.exec(value.trim());
+    if (!match) return 0;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || !amount) return 0;
+    const unit = match[2]?.toLowerCase();
+    const points = 'px' === unit ? 0.75 * amount : 'in' === unit ? 72 * amount : 'cm' === unit ? 72 * amount / 2.54 : 'mm' === unit ? 72 * amount / 25.4 : amount;
+    return Math.round(20 * points);
+}
+function dataPixelLengthToTwips(value, signed = false) {
+    if (void 0 === value) return;
+    const pixels = Number(value);
+    if (!Number.isFinite(pixels)) return;
+    const twips = Math.round(15 * pixels);
+    return signed ? twips : Math.max(0, twips);
+}
+function dataPointLengthToTwips(value) {
+    if (void 0 === value) return;
+    const points = Number(value);
+    return Number.isFinite(points) && points >= 0 ? Math.round(20 * points) : void 0;
+}
+function cssSpacingLengthToTwips(value) {
+    if (!value.trim()) return;
+    if (/^0(?:\.0+)?(?:px|pt|in|cm|mm)?$/i.test(value.trim())) return 0;
+    const points = cssLengthToPoints(value);
+    return void 0 === points ? void 0 : Math.round(20 * points);
+}
+function cssLengthToPoints(value) {
+    const match = /^(-?\d+(?:\.\d+)?)(px|pt|in|cm|mm)$/i.exec(value.trim());
+    if (!match) return;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount <= 0) return;
+    const unit = match[2]?.toLowerCase();
+    if ('px' === unit) return 0.75 * amount;
+    if ('in' === unit) return 72 * amount;
+    if ('cm' === unit) return 72 * amount / 2.54;
+    if ('mm' === unit) return 72 * amount / 25.4;
+    return amount;
+}
+function cssColorToHex(source) {
+    const value = source.trim();
+    const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(value)?.[1];
+    if (hex) return (3 === hex.length ? [
+        ...hex
+    ].map((character)=>character.repeat(2)).join('') : hex).toUpperCase();
+    const rgb = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,[^)]*)?\)$/i.exec(value);
+    if (!rgb) return;
+    return rgb.slice(1, 4).map((channel)=>Math.min(255, Number(channel)).toString(16).padStart(2, '0')).join('').toUpperCase();
+}
+const WORD_2012_NAMESPACE = 'http://schemas.microsoft.com/office/word/2012/wordml';
+const work_docx_paragraph_default_collapsed_MARKUP_COMPATIBILITY_NAMESPACE = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+const MAX_PARAGRAPH_DEFAULT_COLLAPSED_PATCHES = 65536;
+const PARAGRAPH_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
+class DocxParagraphDefaultCollapsedPatchCollector {
+    patches = [];
+    register(marker, element) {
+        const value = dataBoolean(element.dataset.officeDefaultCollapsed);
+        if (void 0 === value) return;
+        if (this.patches.length >= MAX_PARAGRAPH_DEFAULT_COLLAPSED_PATCHES) throw new Error('Document exceeds the default-collapsed paragraph limit.');
+        this.patches.push({
+            marker,
+            value
+        });
+    }
+}
+function parseDocxParagraphDefaultCollapsed(properties) {
+    if ('pPr' !== properties.localName || !DOCX_WORDPROCESSING_NAMESPACES.has(properties.namespaceURI ?? '')) return {
+        status: 'absent'
+    };
+    const collapsed = directChildren(properties, 'collapsed').filter((element)=>element.namespaceURI === WORD_2012_NAMESPACE);
+    if (!collapsed.length) return {
+        status: 'absent'
+    };
+    if (1 !== collapsed.length) return {
+        status: 'invalid'
+    };
+    const element = collapsed[0];
+    if (directChildren(element).length || hasNonWhitespaceXmlText(element)) return {
+        status: 'invalid'
+    };
+    const attributes = Array.from(element.attributes).filter((item)=>xmlAttributeNamespace(element, item) !== XMLNS_NAMESPACE);
+    if (!attributes.length) return {
+        status: 'valid',
+        value: true
+    };
+    if (1 !== attributes.length) return {
+        status: 'invalid'
+    };
+    const valueAttribute = attributes[0];
+    if ('val' !== xmlAttributeLocalName(valueAttribute) || !DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(element, valueAttribute) ?? '')) return {
+        status: 'invalid'
+    };
+    if ('true' === valueAttribute.value || 'on' === valueAttribute.value || '1' === valueAttribute.value) return {
+        status: 'valid',
+        value: true
+    };
+    if ('false' === valueAttribute.value || 'off' === valueAttribute.value || '0' === valueAttribute.value) return {
+        status: 'valid',
+        value: false
+    };
+    return {
+        status: 'invalid'
+    };
+}
+async function patchDocxParagraphDefaultCollapsed(buffer, patches) {
+    if (!patches.length) return buffer;
+    if (patches.length > MAX_PARAGRAPH_DEFAULT_COLLAPSED_PATCHES) throw new Error('Document exceeds the default-collapsed paragraph limit.');
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map(patches.map((patch)=>[
+            patch.marker,
+            patch
+        ]));
+    const applied = new Set();
+    const entries = Object.values(archive.files).filter((entry)=>!entry.dir && PARAGRAPH_PART_PATTERN.test(entry.name));
+    for (const entry of entries){
+        const document = parseXml(decodeXmlBytes(await entry.async('uint8array'), `generated DOCX ${entry.name}`), `generated DOCX ${entry.name}`);
+        if (!isParagraphPartRoot(document.documentElement, entry.name)) continue;
+        let changed = false;
+        for (const paragraph of descendants(document, 'p').filter((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? ''))){
+            const patch = paragraphDefaultCollapsedPatch(paragraph, byMarker);
+            if (patch) {
+                setParagraphDefaultCollapsed(document, paragraph, patch.value);
+                applied.add(patch.marker);
+                changed = true;
+            }
+        }
+        if (changed) archive.file(entry.name, serializeUtf8Xml(document));
+    }
+    const missing = patches.map((patch)=>patch.marker).filter((marker)=>!applied.has(marker));
+    if (missing.length) throw new Error(`DOCX default-collapsed paragraph markers were not emitted: ${missing.join(', ')}.`);
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function paragraphDefaultCollapsedPatch(paragraph, patches) {
+    const matches = directChildren(paragraph, 'r').flatMap((run)=>{
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(run.namespaceURI ?? '')) return [];
+        const text = directChildren(run, 't').find((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? ''));
+        const patch = text ? patches.get(text.textContent ?? '') : void 0;
+        return text && patch && runHasOnlyMarkerText(run, text) ? [
+            patch
+        ] : [];
+    });
+    return 1 === matches.length ? matches[0] : null;
+}
+function runHasOnlyMarkerText(run, markerText) {
+    return directChildren(run).every((child)=>child === markerText || 'rPr' === child.localName && DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? ''));
+}
+function setParagraphDefaultCollapsed(document, paragraph, value) {
+    const wordNamespace = paragraph.namespaceURI ?? '';
+    const root = document.documentElement;
+    const wordPrefix = ensureNamespacePrefix(root, 'w', wordNamespace);
+    const word2012Prefix = ensureNamespacePrefix(root, 'w15', WORD_2012_NAMESPACE);
+    ensureIgnorableNamespace(root, word2012Prefix, WORD_2012_NAMESPACE);
+    const propertyNodes = directChildren(paragraph, 'pPr').filter((element)=>element.namespaceURI === wordNamespace);
+    if (propertyNodes.length > 1) throw new Error('Generated DOCX paragraph contains duplicate properties.');
+    const properties = propertyNodes[0] ?? insertParagraphProperties(document, paragraph, wordPrefix, wordNamespace);
+    for (const child of directChildren(properties, 'collapsed'))if (child.namespaceURI === WORD_2012_NAMESPACE) child.remove();
+    const collapsed = document.createElementNS(WORD_2012_NAMESPACE, `${word2012Prefix}:collapsed`);
+    collapsed.setAttributeNS(wordNamespace, `${wordPrefix}:val`, value ? '1' : '0');
+    properties.append(collapsed);
+}
+function insertParagraphProperties(document, paragraph, wordPrefix, wordNamespace) {
+    const properties = document.createElementNS(wordNamespace, `${wordPrefix}:pPr`);
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function ensureIgnorableNamespace(root, prefix, namespace) {
+    const attribute = Array.from(root.attributes).find((item)=>'Ignorable' === xmlAttributeLocalName(item) && xmlAttributeNamespace(root, item) === work_docx_paragraph_default_collapsed_MARKUP_COMPATIBILITY_NAMESPACE);
+    const tokens = (attribute?.value ?? '').trim().split(/\s+/).filter(Boolean);
+    if (!tokens.some((token)=>xmlNamespaceUri(root, token) === namespace)) tokens.push(prefix);
+    const compatibilityPrefix = ensureNamespacePrefix(root, 'mc', work_docx_paragraph_default_collapsed_MARKUP_COMPATIBILITY_NAMESPACE);
+    attribute?.ownerElement?.removeAttributeNode(attribute);
+    root.setAttributeNS(work_docx_paragraph_default_collapsed_MARKUP_COMPATIBILITY_NAMESPACE, `${compatibilityPrefix}:Ignorable`, tokens.join(' '));
+}
+function ensureNamespacePrefix(root, preferred, namespace) {
+    const existing = xmlDeclaredPrefix(root, namespace);
+    if (existing) return existing;
+    if (!xmlNamespaceUri(root, preferred)) {
+        root.setAttributeNS(XMLNS_NAMESPACE, `xmlns:${preferred}`, namespace);
+        return preferred;
+    }
+    let suffix = 1;
+    let prefix = '';
+    do {
+        prefix = `a3s${suffix}`;
+        suffix += 1;
+    }while (xmlNamespaceUri(root, prefix))
+    root.setAttributeNS(XMLNS_NAMESPACE, `xmlns:${prefix}`, namespace);
+    return prefix;
+}
+function isParagraphPartRoot(root, path) {
+    const expected = /^word\/header\d*\.xml$/i.test(path) ? 'hdr' : /^word\/footer\d*\.xml$/i.test(path) ? 'ftr' : /^word\/footnotes\.xml$/i.test(path) ? 'footnotes' : /^word\/endnotes\.xml$/i.test(path) ? 'endnotes' : 'document';
+    return root.localName === expected && DOCX_WORDPROCESSING_NAMESPACES.has(root.namespaceURI ?? '');
+}
+export { DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, DOCX_WORDPROCESSING_NAMESPACES, DocxParagraphDefaultCollapsedPatchCollector, XMLNS_NAMESPACE, XML_NAMESPACE, assertXmlRoot, cloneXmlElement, createDocxThemeResolver, cssColorToHex, cssFontFamily, cssFontSize, dataBoolean, docxThemeColor, docxThemeFont, domDirection, hasNonWhitespaceXmlText, mergeDocxIgnorableExtensions, mergeDocxIgnorableExtensionsAtPairs, paragraphAlignment, paragraphBidirectional, paragraphDirectionOptions, paragraphIndent, paragraphPaginationOptions, paragraphSpacingOptions, paragraphTabStops, parseDocxColorSchemeMappingElement, parseDocxParagraphDefaultCollapsed, patchDocxBibliography, patchDocxParagraphDefaultCollapsed, readDocxBibliography, resolveDocxThemeResolver, xmlAttributeLocalName, xmlAttributeNamespace, xmlDeclaredPrefix, xmlNamespaceUri };