@a3s-lab/office 0.1.0

package/dist/4704.js

@@ -0,0 +1,1364 @@
+const DEFAULT_DOCUMENT_MARGINS = {
+    top: 25,
+    right: 23,
+    bottom: 25,
+    left: 23
+};
+function documentMargins(content) {
+    return {
+        top: validMargin(content.margins?.top, DEFAULT_DOCUMENT_MARGINS.top),
+        right: validMargin(content.margins?.right, DEFAULT_DOCUMENT_MARGINS.right),
+        bottom: validMargin(content.margins?.bottom, DEFAULT_DOCUMENT_MARGINS.bottom),
+        left: validMargin(content.margins?.left, DEFAULT_DOCUMENT_MARGINS.left)
+    };
+}
+function clampDocumentMargin(value) {
+    return Math.min(60, Math.max(5, Math.round(10 * value) / 10));
+}
+function millimetersToPixels(value) {
+    return 96 * value / 25.4;
+}
+function validMargin(value, fallback) {
+    return Number.isFinite(value) ? clampDocumentMargin(value) : fallback;
+}
+const CAPTION_SELECTOR = 'figcaption[data-document-caption]';
+const REFERENCE_SELECTOR = 'span[data-document-cross-reference]';
+function normalizeDocumentCaptionsHtml(source) {
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    const targets = normalizeCaptions(document);
+    normalizeReferences(document, new Map(targets.map((target)=>[
+            target.id,
+            target
+        ])));
+    return document.body.innerHTML;
+}
+function documentCaptionKind(value) {
+    return 'figure' === value || 'table' === value ? value : null;
+}
+function documentCaptionLabel(kind) {
+    return 'table' === kind ? '表' : '图';
+}
+function documentCaptionDisplay(kind, number) {
+    return `${documentCaptionLabel(kind)} ${positiveInteger(number)}`;
+}
+function normalizeCaptions(document) {
+    const counters = {
+        figure: 0,
+        table: 0
+    };
+    const usedIds = new Set();
+    return Array.from(document.body.querySelectorAll(CAPTION_SELECTOR)).map((element, index)=>{
+        const kind = documentCaptionKind(element.dataset.captionKind) ?? 'figure';
+        counters[kind] += 1;
+        const number = counters[kind];
+        const id = uniqueCaptionId(element.dataset.captionId, kind, index + 1, usedIds);
+        const label = documentCaptionLabel(kind);
+        element.dataset.documentCaption = 'true';
+        element.dataset.captionId = id;
+        element.dataset.captionKind = kind;
+        element.dataset.captionNumber = String(number);
+        element.dataset.captionLabel = label;
+        element.classList.add('work-document-caption');
+        const title = element.textContent?.replace(/\s+/g, ' ').trim() ?? '';
+        const display = documentCaptionDisplay(kind, number);
+        element.setAttribute('aria-label', title ? `${display} ${title}` : display);
+        return {
+            id,
+            kind,
+            number,
+            label,
+            title,
+            display
+        };
+    });
+}
+function normalizeReferences(document, targets) {
+    for (const element of Array.from(document.body.querySelectorAll(REFERENCE_SELECTOR))){
+        const id = element.dataset.referenceTargetId?.trim() ?? '';
+        const target = targets.get(id);
+        element.dataset.documentCrossReference = 'true';
+        element.dataset.referenceTargetId = id;
+        element.classList.add('work-document-cross-reference');
+        if (!target) {
+            element.dataset.referenceOrphaned = 'true';
+            element.textContent = '引用缺失';
+            continue;
+        }
+        delete element.dataset.referenceOrphaned;
+        element.dataset.captionKind = target.kind;
+        element.dataset.captionNumber = String(target.number);
+        element.dataset.captionLabel = target.label;
+        element.textContent = target.display;
+    }
+}
+function uniqueCaptionId(source, kind, index, usedIds) {
+    const candidate = source?.trim();
+    if (candidate && !usedIds.has(candidate)) {
+        usedIds.add(candidate);
+        return candidate;
+    }
+    let suffix = index;
+    while(usedIds.has(`document-${kind}-caption-${suffix}`))suffix += 1;
+    const id = `document-${kind}-caption-${suffix}`;
+    usedIds.add(id);
+    return id;
+}
+function positiveInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : 1;
+}
+const CITATION_SELECTOR = 'span[data-document-citation]';
+const BIBLIOGRAPHY_SELECTOR = 'section[data-document-bibliography]';
+const STYLE_DETAILS = {
+    apa: {
+        name: 'APA',
+        selectedStyle: '\\APASixthEditionOfficeOnline.xsl'
+    },
+    mla: {
+        name: 'MLA',
+        selectedStyle: '\\MLASeventhEditionOfficeOnline.xsl'
+    },
+    chicago: {
+        name: 'Chicago',
+        selectedStyle: '\\CHICAGO.XSL'
+    },
+    ieee: {
+        name: 'IEEE',
+        selectedStyle: '\\IEEE.XSL'
+    }
+};
+function createDocumentBibliography(style = 'apa') {
+    return {
+        style,
+        styleName: STYLE_DETAILS[style].name,
+        selectedStyle: STYLE_DETAILS[style].selectedStyle,
+        sources: []
+    };
+}
+function documentCitationStyle(value) {
+    if ('mla' === value || 'chicago' === value || 'ieee' === value) return value;
+    return 'apa';
+}
+function documentCitationStyleDetails(style) {
+    return STYLE_DETAILS[style];
+}
+function documentCitationTagsFromInstruction(instruction) {
+    const primary = /^\s*CITATION\s+(?:"([^"]+)"|([^\s\\]+))/i.exec(instruction);
+    if (!primary) return [];
+    const tags = [
+        primary[1] || primary[2]
+    ];
+    const additional = /\\m\s+(?:"([^"]+)"|([^\s\\]+))/gi;
+    for (const match of instruction.matchAll(additional))tags.push(match[1] || match[2]);
+    return uniqueCitationTags(tags);
+}
+function documentCitationInstruction(tags) {
+    const normalized = uniqueCitationTags(tags);
+    if (!normalized.length) return '';
+    return [
+        'CITATION',
+        citationTagInstructionValue(normalized[0]),
+        ...normalized.slice(1).flatMap((tag)=>[
+                '\\m',
+                citationTagInstructionValue(tag)
+            ]),
+        '\\l',
+        '2052'
+    ].join(' ');
+}
+function renameDocumentCitationTagInInstruction(instruction, previousTag, nextTag) {
+    return instruction.replace(/(^\s*CITATION\s+|\\m\s+)("[^"]+"|[^\s\\]+)/gi, (match, prefix, source)=>{
+        const tag = source.startsWith('"') ? source.slice(1, -1) : source;
+        return tag === previousTag ? `${prefix}${citationTagInstructionValue(nextTag)}` : match;
+    });
+}
+function documentCitationTags(value) {
+    return uniqueCitationTags((value ?? '').split(/\s+/));
+}
+function isValidDocumentCitationTag(value) {
+    return /^[A-Za-z0-9_:.+-]{1,80}$/.test(value);
+}
+function resolveDocumentCitation(tags, bibliography, instruction = '', cachedValue = '') {
+    const normalized = uniqueCitationTags(tags);
+    if (!normalized.length) return {
+        text: cachedValue || '缺失引文',
+        orphaned: true
+    };
+    const sources = new Map((bibliography?.sources ?? []).map((source)=>[
+            source.tag,
+            source
+        ]));
+    const missing = normalized.filter((tag)=>!sources.has(tag));
+    if (missing.length) return {
+        text: 1 === missing.length ? `缺失引文：${missing[0]}` : `缺失引文：${missing.join('、')}`,
+        orphaned: true
+    };
+    const selected = normalized.flatMap((tag)=>{
+        const source = sources.get(tag);
+        return source ? [
+            source
+        ] : [];
+    });
+    const style = bibliography?.style ?? 'apa';
+    const suppressAuthor = /(?:^|\s)\\n(?:\s|$)/i.test(instruction);
+    const suppressYear = /(?:^|\s)\\v(?:\s|$)/i.test(instruction);
+    const prefix = citationSwitch(instruction, 'f');
+    const suffix = citationSwitch(instruction, 'p');
+    const text = 'ieee' === style ? ieeeCitation(selected, bibliography?.sources ?? []) : 'mla' === style ? mlaCitation(selected, suppressAuthor) : 'chicago' === style ? chicagoCitation(selected, suppressAuthor, suppressYear) : apaCitation(selected, suppressAuthor, suppressYear);
+    return {
+        text: `${prefix}${text}${suffix}`.trim() || cachedValue || normalized.join('; '),
+        orphaned: false
+    };
+}
+function normalizeDocumentCitationsHtml(source, bibliography) {
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    const usedIds = new Set();
+    for (const [index, element] of Array.from(document.body.querySelectorAll(CITATION_SELECTOR)).entries()){
+        const instruction = element.dataset.citationInstruction?.trim() ?? '';
+        const tags = documentCitationTags(element.dataset.citationTags);
+        const normalizedTags = tags.length ? tags : documentCitationTagsFromInstruction(instruction);
+        if (!normalizedTags.length) {
+            element.replaceWith(document.createTextNode(element.textContent ?? ''));
+            continue;
+        }
+        const cached = element.dataset.citationDisplay?.trim() || element.textContent?.trim() || '';
+        const resolved = resolveDocumentCitation(normalizedTags, bibliography, instruction, cached);
+        element.dataset.documentCitation = 'true';
+        element.dataset.citationId = uniqueCitationId(element.dataset.citationId, index + 1, usedIds);
+        element.dataset.citationTags = normalizedTags.join(' ');
+        element.dataset.citationInstruction = instruction || documentCitationInstruction(normalizedTags);
+        element.dataset.citationDisplay = resolved.text;
+        if (resolved.orphaned) element.dataset.citationOrphaned = 'true';
+        else delete element.dataset.citationOrphaned;
+        element.classList.add('work-document-citation');
+        element.textContent = resolved.text;
+    }
+    for (const [index, element] of Array.from(document.body.querySelectorAll(BIBLIOGRAPHY_SELECTOR)).entries()){
+        if (!bibliography) continue;
+        const replacement = createBibliographyElement(document, bibliography, element.dataset.bibliographyId || `document-bibliography-${index + 1}`);
+        element.replaceWith(replacement);
+    }
+    return document.body.innerHTML;
+}
+function renderDocumentBibliographyHtml(bibliography, id = 'document-bibliography-1') {
+    const document = new DOMParser().parseFromString('', 'text/html');
+    document.body.append(createBibliographyElement(document, bibliography, id));
+    return document.body.innerHTML;
+}
+function documentBibliographyEntry(source, bibliography, index) {
+    const people = primaryCitationContributor(source);
+    const authors = people?.corporate?.trim() || people?.people?.map((person)=>bibliographyPersonName(person, bibliography.style)).join(', ') || '未知作者';
+    const title = source.title.trim() || 'Untitled';
+    const year = source.year?.trim() || 'n.d.';
+    const container = citationContainer(source);
+    const url = source.url?.trim();
+    if ('ieee' === bibliography.style) return [
+        `[${index + 1}] ${authors}, “${title}.”`,
+        container ? `${container},` : '',
+        year ? `${year}.` : '',
+        url ?? ''
+    ].filter(Boolean).join(' ');
+    if ('mla' === bibliography.style) return [
+        `${authors}.`,
+        `“${title}.”`,
+        container ? `${container},` : '',
+        `${year}.`,
+        url ?? ''
+    ].filter(Boolean).join(' ');
+    if ('chicago' === bibliography.style) return [
+        `${authors}.`,
+        `${year}.`,
+        `“${title}.”`,
+        container ? `${container}.` : '',
+        url ?? ''
+    ].filter(Boolean).join(' ');
+    return [
+        `${authors}.`,
+        `(${year}).`,
+        `${title}.`,
+        container ? `${container}.` : '',
+        url ?? ''
+    ].filter(Boolean).join(' ');
+}
+function primaryCitationContributor(source) {
+    return source.contributors?.Author ?? Object.values(source.contributors ?? {})[0];
+}
+function createBibliographyElement(document, bibliography, id) {
+    const section = document.createElement('section');
+    section.dataset.documentBibliography = 'true';
+    section.dataset.bibliographyId = id;
+    section.dataset.bibliographyStyle = bibliography.style;
+    section.className = 'work-document-bibliography';
+    const heading = document.createElement('h2');
+    heading.textContent = '参考文献';
+    section.append(heading);
+    if (!bibliography.sources.length) {
+        const empty = document.createElement('p');
+        empty.dataset.bibliographyEmpty = 'true';
+        empty.textContent = '尚无文献源';
+        section.append(empty);
+        return section;
+    }
+    bibliography.sources.forEach((source, index)=>{
+        const paragraph = document.createElement('p');
+        paragraph.dataset.bibliographyEntry = source.tag;
+        paragraph.textContent = documentBibliographyEntry(source, bibliography, index);
+        section.append(paragraph);
+    });
+    return section;
+}
+function apaCitation(sources, suppressAuthor, suppressYear) {
+    const items = sources.map((source)=>{
+        const author = suppressAuthor ? '' : citationAuthor(source, '&');
+        const year = suppressYear ? '' : source.year?.trim() || 'n.d.';
+        return [
+            author,
+            year
+        ].filter(Boolean).join(', ');
+    });
+    return `(${items.join('; ')})`;
+}
+function mlaCitation(sources, suppressAuthor) {
+    return `(${sources.map((source)=>suppressAuthor ? source.year?.trim() || 'n.d.' : citationAuthor(source, 'and')).join('; ')})`;
+}
+function chicagoCitation(sources, suppressAuthor, suppressYear) {
+    return `(${sources.map((source)=>[
+            suppressAuthor ? '' : citationAuthor(source, 'and'),
+            suppressYear ? '' : source.year?.trim() || 'n.d.'
+        ].filter(Boolean).join(' ')).join('; ')})`;
+}
+function ieeeCitation(sources, allSources) {
+    const indexes = sources.map((source)=>allSources.findIndex((candidate)=>candidate.id === source.id || candidate.tag === source.tag) + 1).filter((index)=>index > 0);
+    return `[${indexes.join(', ')}]`;
+}
+function citationAuthor(source, conjunction) {
+    const contributor = primaryCitationContributor(source);
+    if (contributor?.corporate?.trim()) return contributor.corporate.trim();
+    const names = (contributor?.people ?? []).map((person)=>person.last.trim() || person.first.trim()).filter(Boolean);
+    if (!names.length) return source.title.trim() || source.tag;
+    if (1 === names.length) return names[0];
+    if (2 === names.length) return `${names[0]} ${conjunction} ${names[1]}`;
+    return `${names[0]} et al.`;
+}
+function bibliographyPersonName(person, style) {
+    const first = [
+        person.first,
+        person.middle
+    ].filter(Boolean).join(' ').trim();
+    const suffix = person.suffix?.trim();
+    if ('ieee' === style) {
+        const initials = [
+            person.first,
+            person.middle
+        ].filter(Boolean).map((value)=>`${Array.from(value ?? '')[0] ?? ''}.`).join(' ');
+        return [
+            initials,
+            person.last,
+            suffix
+        ].filter(Boolean).join(' ');
+    }
+    return [
+        person.last,
+        first ? `, ${first}` : '',
+        suffix ? `, ${suffix}` : ''
+    ].join('');
+}
+function citationContainer(source) {
+    return source.journalName?.trim() || source.publisher?.trim() || source.conferenceName?.trim() || source.institution?.trim() || '';
+}
+function citationSwitch(instruction, name) {
+    const expression = new RegExp(`\\\\${name}\\s+"([^"]*)"`, 'i');
+    return expression.exec(instruction)?.[1] ?? '';
+}
+function citationTagInstructionValue(tag) {
+    return /^[A-Za-z0-9_:.+-]+$/.test(tag) ? tag : `"${tag.replaceAll('"', '')}"`;
+}
+function uniqueCitationTags(tags) {
+    const result = [];
+    const seen = new Set();
+    for (const source of tags){
+        const tag = source.trim();
+        if (!(!tag || seen.has(tag))) {
+            seen.add(tag);
+            result.push(tag);
+        }
+    }
+    return result;
+}
+function uniqueCitationId(source, index, usedIds) {
+    const candidate = source?.trim();
+    if (candidate && !usedIds.has(candidate)) {
+        usedIds.add(candidate);
+        return candidate;
+    }
+    let suffix = index;
+    while(usedIds.has(`document-citation-${suffix}`))suffix += 1;
+    const id = `document-citation-${suffix}`;
+    usedIds.add(id);
+    return id;
+}
+const FIELD_SELECTOR = 'span[data-document-field]';
+const FIELD_COMMANDS = {
+    page: 'PAGE',
+    numPages: 'NUMPAGES',
+    section: 'SECTION',
+    sectionPages: 'SECTIONPAGES',
+    date: 'DATE \\@ "yyyy年M月d日"',
+    time: 'TIME \\@ "HH:mm"'
+};
+const FIELD_LABELS = {
+    page: '当前页码',
+    numPages: '总页数',
+    section: '当前节号',
+    sectionPages: '本节页数',
+    date: '当前日期',
+    time: '当前时间'
+};
+function documentFieldKind(value) {
+    if ('page' === value || 'numPages' === value || 'section' === value || 'sectionPages' === value || 'date' === value || 'time' === value) return value;
+    return null;
+}
+function docxDocumentFieldKind(instruction) {
+    const command = /^\s*([a-z][a-z0-9]*)\b/i.exec(instruction)?.[1]?.toUpperCase();
+    if ('PAGE' === command) return 'page';
+    if ('NUMPAGES' === command) return 'numPages';
+    if ('SECTION' === command) return 'section';
+    if ('SECTIONPAGES' === command) return 'sectionPages';
+    if ('DATE' === command) return 'date';
+    if ('TIME' === command) return 'time';
+    return null;
+}
+function documentFieldInstruction(kind) {
+    return FIELD_COMMANDS[kind];
+}
+function documentFieldLabel(kind) {
+    return FIELD_LABELS[kind];
+}
+function documentFieldDisplay(kind, context, instruction = documentFieldInstruction(kind), cachedValue = '') {
+    if ('page' === kind) return String(work_document_fields_positiveInteger(context.pageNumber));
+    if ('numPages' === kind) return String(work_document_fields_positiveInteger(context.totalPages));
+    if ('section' === kind) return String(work_document_fields_positiveInteger(context.sectionNumber));
+    if ('sectionPages' === kind) return String(work_document_fields_positiveInteger(context.sectionPages));
+    const now = validDate(context.now) ?? new Date();
+    const format = dateFormatSwitch(instruction) ?? ('date' === kind ? 'yyyy年M月d日' : 'HH:mm');
+    const display = formatWordDate(now, format);
+    return display || cachedValue || documentFieldLabel(kind);
+}
+function normalizeDocumentFieldsHtml(source) {
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    const usedIds = new Set();
+    for (const [index, element] of Array.from(document.body.querySelectorAll(FIELD_SELECTOR)).entries()){
+        const instruction = element.dataset.fieldInstruction?.trim() ?? '';
+        const kind = documentFieldKind(element.dataset.fieldKind) ?? docxDocumentFieldKind(instruction);
+        if (!kind) {
+            element.replaceWith(document.createTextNode(element.textContent ?? ''));
+            continue;
+        }
+        const display = element.dataset.fieldDisplay?.trim() || element.textContent?.trim() || documentFieldLabel(kind);
+        element.dataset.documentField = 'true';
+        element.dataset.fieldId = uniqueFieldId(element.dataset.fieldId, index + 1, usedIds);
+        element.dataset.fieldKind = kind;
+        element.dataset.fieldInstruction = instruction || documentFieldInstruction(kind);
+        element.dataset.fieldDisplay = display;
+        element.classList.add('work-document-field');
+        element.textContent = display;
+    }
+    return document.body.innerHTML;
+}
+function resolveDocumentFieldsHtml(source, context) {
+    const document = new DOMParser().parseFromString(normalizeDocumentFieldsHtml(source), 'text/html');
+    for (const element of Array.from(document.body.querySelectorAll(FIELD_SELECTOR))){
+        const kind = documentFieldKind(element.dataset.fieldKind);
+        if (!kind) continue;
+        const display = documentFieldDisplay(kind, context, element.dataset.fieldInstruction, element.dataset.fieldDisplay);
+        element.dataset.fieldDisplay = display;
+        element.textContent = display;
+    }
+    return document.body.innerHTML;
+}
+function uniqueFieldId(source, index, usedIds) {
+    const candidate = source?.trim();
+    if (candidate && !usedIds.has(candidate)) {
+        usedIds.add(candidate);
+        return candidate;
+    }
+    let suffix = index;
+    while(usedIds.has(`document-field-${suffix}`))suffix += 1;
+    const id = `document-field-${suffix}`;
+    usedIds.add(id);
+    return id;
+}
+function dateFormatSwitch(instruction) {
+    return /\\@\s+"([^"]+)"/i.exec(instruction)?.[1] ?? null;
+}
+function formatWordDate(date, format) {
+    const hour12 = date.getHours() % 12 || 12;
+    const replacements = {
+        'AM/PM': date.getHours() < 12 ? 'AM' : 'PM',
+        'am/pm': date.getHours() < 12 ? 'am' : 'pm',
+        yyyy: String(date.getFullYear()).padStart(4, '0'),
+        yy: String(date.getFullYear() % 100).padStart(2, '0'),
+        MMMM: new Intl.DateTimeFormat('zh-CN', {
+            month: 'long'
+        }).format(date),
+        MMM: new Intl.DateTimeFormat('zh-CN', {
+            month: 'short'
+        }).format(date),
+        MM: String(date.getMonth() + 1).padStart(2, '0'),
+        M: String(date.getMonth() + 1),
+        dddd: new Intl.DateTimeFormat('zh-CN', {
+            weekday: 'long'
+        }).format(date),
+        ddd: new Intl.DateTimeFormat('zh-CN', {
+            weekday: 'short'
+        }).format(date),
+        dd: String(date.getDate()).padStart(2, '0'),
+        d: String(date.getDate()),
+        HH: String(date.getHours()).padStart(2, '0'),
+        H: String(date.getHours()),
+        hh: String(hour12).padStart(2, '0'),
+        h: String(hour12),
+        mm: String(date.getMinutes()).padStart(2, '0'),
+        m: String(date.getMinutes()),
+        ss: String(date.getSeconds()).padStart(2, '0'),
+        s: String(date.getSeconds())
+    };
+    return format.replace(/AM\/PM|am\/pm|yyyy|MMMM|dddd|MMM|ddd|yy|MM|dd|HH|hh|mm|ss|M|d|H|h|m|s/g, (token)=>replacements[token] ?? token);
+}
+function work_document_fields_positiveInteger(value) {
+    return Number.isSafeInteger(value) && value > 0 ? value : 1;
+}
+function validDate(value) {
+    return value && Number.isFinite(value.getTime()) ? value : null;
+}
+const NOTE_REFERENCE_SELECTOR = 'sup[data-document-note-reference]';
+const NOTE_DEFINITION_SELECTOR = 'aside[data-document-note]';
+function normalizeDocumentNotesHtml(source) {
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    const definitions = new Map();
+    for (const element of Array.from(document.body.querySelectorAll(NOTE_DEFINITION_SELECTOR))){
+        const kind = documentNoteKind(element.dataset.noteKind);
+        const id = element.dataset.noteId?.trim();
+        if (!kind || !id) {
+            element.remove();
+            continue;
+        }
+        const key = documentNoteKey(kind, id);
+        if (definitions.has(key)) {
+            element.remove();
+            continue;
+        }
+        definitions.set(key, element);
+    }
+    const counters = {
+        footnote: 0,
+        endnote: 0
+    };
+    const numbers = new Map();
+    const references = new Map();
+    for (const element of Array.from(document.body.querySelectorAll(NOTE_REFERENCE_SELECTOR))){
+        const kind = documentNoteKind(element.dataset.noteKind) ?? 'footnote';
+        const id = element.dataset.noteId?.trim() || nextDocumentNoteId(kind, counters[kind] + 1, numbers);
+        const key = documentNoteKey(kind, id);
+        let number = numbers.get(key);
+        if (!number) {
+            counters[kind] += 1;
+            number = counters[kind];
+            numbers.set(key, number);
+            references.set(key, element);
+        }
+        applyDocumentNoteAttributes(element, kind, id, number, true);
+        element.textContent = String(number);
+    }
+    for (const [key, element] of definitions){
+        const number = numbers.get(key);
+        if (!number) {
+            element.remove();
+            continue;
+        }
+        const { kind, id } = splitDocumentNoteKey(key);
+        applyDocumentNoteAttributes(element, kind, id, number, false);
+        ensureDocumentNoteBlocks(element);
+    }
+    for (const [key, number] of numbers){
+        if (definitions.has(key)) continue;
+        const { kind, id } = splitDocumentNoteKey(key);
+        const note = createDocumentNoteElement(document, {
+            id,
+            kind,
+            number,
+            html: '<p></p>'
+        });
+        const reference = references.get(key);
+        const target = 'footnote' === kind ? reference?.closest('section[data-document-section]') : document.body.querySelector('section[data-document-section]:last-of-type');
+        (target ?? document.body).append(note);
+    }
+    return document.body.innerHTML;
+}
+function collectDocumentNotes(source) {
+    const html = normalizeDocumentNotesHtml(source);
+    const document = new DOMParser().parseFromString(html, 'text/html');
+    const definitions = new Map();
+    for (const element of Array.from(document.body.querySelectorAll(NOTE_DEFINITION_SELECTOR))){
+        const kind = documentNoteKind(element.dataset.noteKind);
+        const id = element.dataset.noteId?.trim();
+        if (kind && id) definitions.set(documentNoteKey(kind, id), element);
+    }
+    const seen = new Set();
+    const notes = [];
+    for (const reference of Array.from(document.body.querySelectorAll(NOTE_REFERENCE_SELECTOR))){
+        const kind = documentNoteKind(reference.dataset.noteKind);
+        const id = reference.dataset.noteId?.trim();
+        if (!kind || !id) continue;
+        const key = documentNoteKey(kind, id);
+        if (seen.has(key)) continue;
+        const definition = definitions.get(key);
+        if (definition) {
+            seen.add(key);
+            notes.push({
+                id,
+                kind,
+                number: work_document_notes_positiveInteger(reference.dataset.noteNumber, notes.length + 1),
+                html: definition.innerHTML || '<p></p>'
+            });
+        }
+    }
+    return {
+        html,
+        notes
+    };
+}
+function documentNoteReferenceKeys(source) {
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    const keys = [];
+    for (const reference of Array.from(document.body.querySelectorAll(NOTE_REFERENCE_SELECTOR))){
+        const kind = documentNoteKind(reference.dataset.noteKind);
+        const id = reference.dataset.noteId?.trim();
+        if (kind && id) keys.push(documentNoteKey(kind, id));
+    }
+    return keys;
+}
+function removeDocumentNoteDefinitions(source) {
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    for (const note of Array.from(document.body.querySelectorAll(NOTE_DEFINITION_SELECTOR)))note.remove();
+    return document.body.innerHTML;
+}
+function createDocumentNoteElement(document, note) {
+    const element = document.createElement('aside');
+    applyDocumentNoteAttributes(element, note.kind, note.id, note.number, false);
+    element.innerHTML = note.html || '<p></p>';
+    ensureDocumentNoteBlocks(element);
+    return element;
+}
+function documentNoteKey(kind, id) {
+    return `${kind}:${id}`;
+}
+function documentNoteKind(value) {
+    if ('footnote' === value || 'endnote' === value) return value;
+    return null;
+}
+function applyDocumentNoteAttributes(element, kind, id, number, reference) {
+    element.setAttribute(reference ? 'data-document-note-reference' : 'data-document-note', 'true');
+    element.setAttribute('data-note-kind', kind);
+    element.setAttribute('data-note-id', id);
+    element.setAttribute('data-note-number', String(number));
+}
+function splitDocumentNoteKey(key) {
+    const separator = key.indexOf(':');
+    return {
+        kind: key.slice(0, separator),
+        id: key.slice(separator + 1)
+    };
+}
+function nextDocumentNoteId(kind, seed, existing) {
+    let suffix = seed;
+    while(existing.has(documentNoteKey(kind, `document-${kind}-${suffix}`)))suffix += 1;
+    return `document-${kind}-${suffix}`;
+}
+function ensureDocumentNoteBlocks(element) {
+    if (element.children.length) return;
+    const text = element.textContent ?? '';
+    element.replaceChildren();
+    const paragraph = element.ownerDocument.createElement('p');
+    paragraph.textContent = text;
+    element.append(paragraph);
+}
+function work_document_notes_positiveInteger(value, fallback) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : fallback;
+}
+const DEFAULT_DOCUMENT_COLUMNS = {
+    count: 1,
+    spacing: 12,
+    separator: false
+};
+const MAX_COLUMNS = 6;
+const MIN_COLUMN_PERCENT = 5;
+function normalizeDocumentColumns(columns) {
+    const customCount = Array.isArray(columns?.custom) ? columns.custom.length : 0;
+    const count = clampInteger(columns?.count, customCount || DEFAULT_DOCUMENT_COLUMNS.count, 1, MAX_COLUMNS);
+    const spacing = clampNumber(columns?.spacing, DEFAULT_DOCUMENT_COLUMNS.spacing, 0, 30);
+    const normalized = {
+        count,
+        spacing: roundOne(spacing),
+        separator: Boolean(columns?.separator)
+    };
+    if (count < 2 || !customCount) return normalized;
+    const source = columns?.custom ?? [];
+    const widths = normalizedPercentages(Array.from({
+        length: count
+    }, (_, index)=>finiteNumber(source[index]?.widthPercent, 100 / count)), 100, MIN_COLUMN_PERCENT);
+    normalized.custom = Array.from({
+        length: count
+    }, (_, index)=>({
+            widthPercent: widths[index],
+            spacing: index === count - 1 ? 0 : roundOne(clampNumber(source[index]?.spacing, normalized.spacing, 0, 30))
+        }));
+    return normalized;
+}
+function serializeDocumentColumns(columns) {
+    return JSON.stringify(normalizeDocumentColumns(columns));
+}
+function parseDocumentColumns(source, legacy = {}, fallback) {
+    if (source?.trim()) try {
+        return normalizeDocumentColumns(JSON.parse(source));
+    } catch  {}
+    if (void 0 !== legacy.count || void 0 !== legacy.spacing || void 0 !== legacy.separator) return normalizeDocumentColumns(legacy);
+    return normalizeDocumentColumns(fallback);
+}
+function setCustomDocumentColumns(columns, enabled) {
+    const normalized = normalizeDocumentColumns(columns);
+    if (!enabled || normalized.count < 2) return {
+        ...normalized,
+        custom: void 0
+    };
+    if (normalized.custom) return normalized;
+    return normalizeDocumentColumns({
+        ...normalized,
+        custom: Array.from({
+            length: normalized.count
+        }, (_, index)=>({
+                widthPercent: 100 / normalized.count,
+                spacing: index === normalized.count - 1 ? 0 : normalized.spacing
+            }))
+    });
+}
+function updateDocumentColumnWidth(columns, index, widthPercent) {
+    const normalized = setCustomDocumentColumns(columns, true);
+    if (!normalized.custom?.[index]) return normalized;
+    const maximum = 100 - MIN_COLUMN_PERCENT * (normalized.custom.length - 1);
+    const target = Math.min(maximum, Math.max(MIN_COLUMN_PERCENT, finiteNumber(widthPercent, 100 / normalized.count)));
+    const otherIndexes = normalized.custom.map((_, itemIndex)=>itemIndex).filter((itemIndex)=>itemIndex !== index);
+    const otherWidths = normalizedPercentages(otherIndexes.map((itemIndex)=>normalized.custom?.[itemIndex].widthPercent ?? 1), 100 - target, MIN_COLUMN_PERCENT);
+    const custom = normalized.custom.map((column, itemIndex)=>{
+        const otherIndex = otherIndexes.indexOf(itemIndex);
+        return {
+            ...column,
+            widthPercent: itemIndex === index ? roundOne(target) : otherWidths[otherIndex]
+        };
+    });
+    return {
+        ...normalized,
+        custom
+    };
+}
+function normalizedPercentages(values, total, minimum) {
+    if (!values.length) return [];
+    const result = Array(values.length).fill(0);
+    const remaining = new Set(values.map((_, index)=>index));
+    let remainingTotal = total;
+    while(remaining.size){
+        const sourceTotal = Array.from(remaining).reduce((sum, index)=>sum + Math.max(0.001, finiteNumber(values[index], 1)), 0);
+        const belowMinimum = Array.from(remaining).filter((index)=>Math.max(0.001, finiteNumber(values[index], 1)) / sourceTotal * remainingTotal < minimum);
+        if (!belowMinimum.length) {
+            for (const index of remaining)result[index] = Math.max(0.001, finiteNumber(values[index], 1)) / sourceTotal * remainingTotal;
+            break;
+        }
+        for (const index of belowMinimum){
+            result[index] = minimum;
+            remaining.delete(index);
+            remainingTotal -= minimum;
+        }
+    }
+    const rounded = result.map(roundOne);
+    const adjustmentIndex = rounded.indexOf(Math.max(...rounded));
+    rounded[adjustmentIndex] = roundOne(rounded[adjustmentIndex] + total - rounded.reduce((sum, value)=>sum + value, 0));
+    return rounded;
+}
+function clampInteger(value, fallback, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, Math.round(finiteNumber(value, fallback))));
+}
+function clampNumber(value, fallback, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, finiteNumber(value, fallback)));
+}
+function finiteNumber(value, fallback) {
+    return Number.isFinite(value) ? Number(value) : fallback;
+}
+function roundOne(value) {
+    return Math.round(10 * value) / 10;
+}
+const EMPTY_CONTENT = {
+    headerHtml: '',
+    footerHtml: '',
+    showPageNumber: false
+};
+const ALLOWED_TAGS = new Set([
+    'a',
+    'b',
+    'blockquote',
+    'br',
+    'div',
+    'em',
+    'i',
+    'img',
+    'li',
+    'ol',
+    'p',
+    's',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'th',
+    'thead',
+    'tr',
+    'u',
+    'ul'
+]);
+function normalizeDocumentPageChrome(source, legacy = {}) {
+    const defaultContent = normalizePageChromeContent(source?.default, {
+        headerHtml: plainTextToPageChromeHtml(legacy.headerText),
+        footerHtml: plainTextToPageChromeHtml(legacy.footerText),
+        showPageNumber: Boolean(legacy.showPageNumbers)
+    });
+    return {
+        differentFirstPage: Boolean(source?.differentFirstPage),
+        differentOddEvenPages: Boolean(source?.differentOddEvenPages),
+        default: defaultContent,
+        first: normalizePageChromeContent(source?.first, EMPTY_CONTENT),
+        even: normalizePageChromeContent(source?.even, EMPTY_CONTENT)
+    };
+}
+function serializeDocumentPageChrome(chrome) {
+    return JSON.stringify(normalizeDocumentPageChrome(chrome));
+}
+function parseDocumentPageChrome(source, legacy = {}, fallback) {
+    if (source?.trim()) try {
+        const parsed = JSON.parse(source);
+        return normalizeDocumentPageChrome(parsed, legacy);
+    } catch  {}
+    if (legacy.headerText || legacy.footerText || void 0 !== legacy.showPageNumbers) return normalizeDocumentPageChrome(void 0, legacy);
+    return normalizeDocumentPageChrome(fallback);
+}
+function resolveDocumentPageChrome(layout, sectionPage, physicalPage) {
+    const chrome = normalizeDocumentPageChrome(layout.pageChrome, layout);
+    const variant = chrome.differentFirstPage && 1 === sectionPage ? 'first' : chrome.differentOddEvenPages && physicalPage % 2 === 0 ? 'even' : 'default';
+    return {
+        variant,
+        ...chrome[variant]
+    };
+}
+function documentPageChromeLegacyFields(chrome) {
+    const normalized = normalizeDocumentPageChrome(chrome);
+    return {
+        headerText: pageChromePlainText(normalized.default.headerHtml) || void 0,
+        footerText: pageChromePlainText(normalized.default.footerHtml) || void 0,
+        showPageNumbers: normalized.default.showPageNumber
+    };
+}
+function updateDocumentPageChromeVariant(chrome, variant, patch) {
+    const normalized = normalizeDocumentPageChrome(chrome);
+    return {
+        ...normalized,
+        [variant]: normalizePageChromeContent({
+            ...normalized[variant],
+            ...patch
+        }, EMPTY_CONTENT)
+    };
+}
+function pageChromePlainText(source) {
+    if (!source.trim()) return '';
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    const blocks = Array.from(document.body.querySelectorAll('p, div, li')).map((element)=>element.textContent?.replace(/\s+/g, ' ').trim() ?? '').filter(Boolean);
+    return (blocks.length ? blocks.join('\n') : document.body.textContent ?? '').trim();
+}
+function sanitizeDocumentPageChromeHtml(source) {
+    if (!source?.trim()) return '';
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    for (const element of Array.from(document.body.querySelectorAll("script, iframe, object, embed, link, meta")))element.remove();
+    for (const font of Array.from(document.body.querySelectorAll('font'))){
+        const span = document.createElement('span');
+        const color = font.getAttribute('color')?.trim();
+        if (font.getAttribute('style')) span.setAttribute('style', font.getAttribute('style') ?? '');
+        if (color && !span.style.color) span.style.color = color;
+        span.append(...Array.from(font.childNodes));
+        font.replaceWith(span);
+    }
+    for (const element of Array.from(document.body.querySelectorAll('*'))){
+        const tag = element.tagName.toLowerCase();
+        if (!ALLOWED_TAGS.has(tag)) {
+            element.replaceWith(...Array.from(element.childNodes));
+            continue;
+        }
+        sanitizeAttributes(element, tag);
+    }
+    if (!(document.body.textContent ?? '').trim() && !document.body.querySelector('img, table')) return '';
+    return document.body.innerHTML;
+}
+function plainTextToPageChromeHtml(source) {
+    const lines = source?.split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
+    if (!lines?.length) return '';
+    return lines.map((line)=>`<p style="text-align: center">${escapeHtml(line)}</p>`).join('');
+}
+function normalizePageChromeContent(source, fallback) {
+    return {
+        headerHtml: sanitizeDocumentPageChromeHtml(source?.headerHtml ?? fallback.headerHtml),
+        footerHtml: sanitizeDocumentPageChromeHtml(source?.footerHtml ?? fallback.footerHtml),
+        showPageNumber: source?.showPageNumber ?? fallback.showPageNumber
+    };
+}
+function sanitizeAttributes(element, tag) {
+    for (const attribute of Array.from(element.attributes))if (attribute.name.toLowerCase().startsWith('on')) element.removeAttribute(attribute.name);
+    const textAlign = [
+        'left',
+        'center',
+        'right',
+        'justify'
+    ].includes(element.style.textAlign) ? element.style.textAlign : '';
+    const color = element.style.color;
+    const direction = element.getAttribute('dir')?.trim().toLowerCase();
+    element.removeAttribute('style');
+    const styles = [
+        textAlign ? `text-align: ${textAlign}` : '',
+        color ? `color: ${color}` : ''
+    ].filter(Boolean);
+    if (styles.length) element.setAttribute('style', styles.join('; '));
+    if ('a' === tag) {
+        const href = element.getAttribute('href')?.trim() ?? '';
+        if (!/^(?:https?:|mailto:|#)/i.test(href)) element.removeAttribute('href');
+    } else if ('img' === tag) {
+        const source = element.getAttribute('src')?.trim() ?? '';
+        if (!/^(?:https?:|blob:|data:image\/)/i.test(source)) element.removeAttribute('src');
+    } else if ('ol' === tag) {
+        const start = Number(element.getAttribute('start'));
+        if (!Number.isSafeInteger(start) || start <= 0) element.removeAttribute('start');
+        const type = element.getAttribute('type');
+        if (type && ![
+            '1',
+            'A',
+            'a',
+            'I',
+            'i'
+        ].includes(type)) element.removeAttribute('type');
+    }
+    if ('ltr' === direction || 'rtl' === direction) element.setAttribute('dir', direction);
+    else element.removeAttribute('dir');
+    const allowed = 'a' === tag ? new Set([
+        'dir',
+        'href',
+        'title',
+        'style'
+    ]) : 'img' === tag ? new Set([
+        'dir',
+        'src',
+        'alt',
+        'title',
+        'width',
+        'height',
+        'style'
+    ]) : 'ol' === tag ? new Set([
+        'dir',
+        'start',
+        'style',
+        'type'
+    ]) : new Set([
+        'colspan',
+        'dir',
+        'rowspan',
+        'style'
+    ]);
+    for (const attribute of Array.from(element.attributes))if (!allowed.has(attribute.name.toLowerCase())) element.removeAttribute(attribute.name);
+}
+function escapeHtml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+}
+const DOCUMENT_MODEL_SCHEMA = 'a3s.office.document';
+const DOCUMENT_MODEL_VERSION = 1;
+const MAX_DOCUMENT_MODEL_DEPTH = 256;
+const MAX_DOCUMENT_MODEL_NODES = 100000;
+const MAX_DOCUMENT_MODEL_MARKS = 500000;
+const MAX_DOCUMENT_MODEL_ATTRIBUTE_VALUES = 1000000;
+function createWorkDocumentModel(html, root, previous) {
+    return {
+        schema: DOCUMENT_MODEL_SCHEMA,
+        version: DOCUMENT_MODEL_VERSION,
+        revision: nextRevision(previous),
+        htmlFingerprint: documentHtmlFingerprint(html),
+        root
+    };
+}
+function documentModelForContent(content) {
+    return documentModelForHtml(content.model, content.html);
+}
+function documentModelForHtml(candidate, html) {
+    if (!isRecord(candidate)) return null;
+    if (candidate.schema !== DOCUMENT_MODEL_SCHEMA || candidate.version !== DOCUMENT_MODEL_VERSION || !Number.isSafeInteger(candidate.revision) || Number(candidate.revision) < 1 || candidate.htmlFingerprint !== documentHtmlFingerprint(html) || !isDocumentRoot(candidate.root)) return null;
+    return candidate;
+}
+function resolveWorkDocumentEditorInput(content, fallbackHtml) {
+    const model = documentModelForHtml(content.model, fallbackHtml);
+    if (!model) return {
+        model: null,
+        source: fallbackHtml,
+        sourceKey: `html:${documentHtmlFingerprint(fallbackHtml)}`,
+        revision: 0
+    };
+    return {
+        model,
+        source: model.root,
+        sourceKey: `model:${model.revision}:${model.htmlFingerprint}`,
+        revision: model.revision
+    };
+}
+function documentHtmlFingerprint(html) {
+    let hash = 0x811c9dc5;
+    for(let index = 0; index < html.length; index += 1){
+        hash ^= html.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `${html.length.toString(36)}:${(hash >>> 0).toString(36)}`;
+}
+function nextRevision(previous) {
+    const revision = previous?.schema === DOCUMENT_MODEL_SCHEMA && previous.version === DOCUMENT_MODEL_VERSION && Number.isSafeInteger(previous.revision) && previous.revision > 0 ? previous.revision : 0;
+    return revision >= Number.MAX_SAFE_INTEGER ? 1 : revision + 1;
+}
+function isDocumentRoot(value) {
+    if (!isRecord(value) || 'doc' !== value.type) return false;
+    const nodes = [
+        {
+            value,
+            depth: 0
+        }
+    ];
+    const seen = new WeakSet();
+    let nodeCount = 0;
+    let markCount = 0;
+    let attributeValueCount = 0;
+    while(nodes.length){
+        const current = nodes.pop();
+        if (!current || !isRecord(current.value)) return false;
+        if (current.depth > MAX_DOCUMENT_MODEL_DEPTH || seen.has(current.value)) return false;
+        seen.add(current.value);
+        nodeCount += 1;
+        if (nodeCount > MAX_DOCUMENT_MODEL_NODES) return false;
+        if ('string' != typeof current.value.type || !current.value.type.trim() || void 0 !== current.value.text && 'string' != typeof current.value.text) return false;
+        if ('text' === current.value.type && 'string' != typeof current.value.text) return false;
+        if (void 0 !== current.value.attrs) {
+            const result = validateAttributes(current.value.attrs, attributeValueCount);
+            if (!result.valid) return false;
+            attributeValueCount = result.count;
+        }
+        if (void 0 !== current.value.marks) {
+            if (!Array.isArray(current.value.marks)) return false;
+            markCount += current.value.marks.length;
+            if (markCount > MAX_DOCUMENT_MODEL_MARKS) return false;
+            for (const mark of current.value.marks){
+                if (!isDocumentMark(mark)) return false;
+                if (void 0 !== mark.attrs) {
+                    const result = validateAttributes(mark.attrs, attributeValueCount);
+                    if (!result.valid) return false;
+                    attributeValueCount = result.count;
+                }
+            }
+        }
+        if (void 0 !== current.value.content) {
+            if (!Array.isArray(current.value.content)) return false;
+            for(let index = current.value.content.length - 1; index >= 0; index -= 1)nodes.push({
+                value: current.value.content[index],
+                depth: current.depth + 1
+            });
+        }
+    }
+    return true;
+}
+function isDocumentMark(value) {
+    return isRecord(value) && 'string' == typeof value.type && Boolean(value.type.trim()) && (void 0 === value.attrs || isRecord(value.attrs));
+}
+function validateAttributes(value, initialCount) {
+    if (!isRecord(value)) return {
+        valid: false,
+        count: initialCount
+    };
+    const values = Object.values(value);
+    const stack = values.map((item)=>({
+            item,
+            depth: 0
+        }));
+    const seen = new WeakSet();
+    let count = initialCount;
+    while(stack.length){
+        const current = stack.pop();
+        if (!current) break;
+        count += 1;
+        if (count > MAX_DOCUMENT_MODEL_ATTRIBUTE_VALUES || current.depth > 32) return {
+            valid: false,
+            count
+        };
+        if (null === current.item || 'string' == typeof current.item || 'boolean' == typeof current.item || 'number' == typeof current.item && Number.isFinite(current.item)) continue;
+        if ('object' != typeof current.item) return {
+            valid: false,
+            count
+        };
+        if (seen.has(current.item)) return {
+            valid: false,
+            count
+        };
+        seen.add(current.item);
+        const nested = Array.isArray(current.item) ? current.item : Object.values(current.item);
+        for (const item of nested)stack.push({
+            item,
+            depth: current.depth + 1
+        });
+    }
+    return {
+        valid: true,
+        count
+    };
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const SECTION_SELECTOR = 'section[data-document-section]';
+function documentInitialSectionLayout(content) {
+    const pageChrome = normalizeDocumentPageChrome(content.pageChrome, content);
+    const legacy = documentPageChromeLegacyFields(pageChrome);
+    return {
+        pageSize: content.pageSize,
+        orientation: content.orientation ?? 'portrait',
+        margins: documentMargins(content),
+        columns: normalizeDocumentColumns(content.columns),
+        breakAfter: 'nextPage',
+        headerText: legacy.headerText,
+        footerText: legacy.footerText,
+        showPageNumbers: legacy.showPageNumbers,
+        pageNumberStart: validPageNumber(content.pageNumberStart),
+        pageChrome
+    };
+}
+function normalizeDocumentHtml(content) {
+    const document = new DOMParser().parseFromString(content.html, 'text/html');
+    const directSections = Array.from(document.body.children).filter((element)=>element.matches(SECTION_SELECTOR));
+    if (!directSections.length) {
+        const section = document.createElement('section');
+        applyDocumentSectionDomAttributes(section, documentInitialSectionLayout(content), 'document-section-1');
+        while(document.body.firstChild)section.append(document.body.firstChild);
+        if (!section.childNodes.length) section.innerHTML = '<p></p>';
+        document.body.append(section);
+        return normalizeDocumentSemanticHtml(document.body.innerHTML, content.bibliography);
+    }
+    let activeSection = directSections[0];
+    for (const node of Array.from(document.body.childNodes)){
+        if (node instanceof HTMLElement && node.matches(SECTION_SELECTOR)) {
+            activeSection = node;
+            continue;
+        }
+        activeSection.append(node);
+    }
+    let fallback = documentInitialSectionLayout(content);
+    directSections.forEach((element, index)=>{
+        const layout = documentSectionLayoutFromElement(element, fallback);
+        applyDocumentSectionDomAttributes(element, layout, element.getAttribute('data-section-id') || `document-section-${index + 1}`);
+        if (!element.childNodes.length) element.innerHTML = '<p></p>';
+        fallback = layout;
+    });
+    return normalizeDocumentSemanticHtml(document.body.innerHTML, content.bibliography);
+}
+function documentSections(content) {
+    const document = new DOMParser().parseFromString(normalizeDocumentHtml(content), 'text/html');
+    let fallback = documentInitialSectionLayout(content);
+    return Array.from(document.body.querySelectorAll(`:scope > ${SECTION_SELECTOR}`)).map((element, index)=>{
+        const layout = documentSectionLayoutFromElement(element, fallback);
+        fallback = layout;
+        return {
+            id: element.dataset.sectionId || `document-section-${index + 1}`,
+            layout,
+            html: element.innerHTML || '<p></p>'
+        };
+    });
+}
+function documentSectionNodeAttributes(layout, id) {
+    const columns = normalizeDocumentColumns(layout.columns);
+    const pageChrome = normalizeDocumentPageChrome(layout.pageChrome, layout);
+    const legacy = documentPageChromeLegacyFields(pageChrome);
+    return {
+        id,
+        pageSize: layout.pageSize,
+        orientation: layout.orientation,
+        marginTop: layout.margins.top,
+        marginRight: layout.margins.right,
+        marginBottom: layout.margins.bottom,
+        marginLeft: layout.margins.left,
+        columnCount: columns.count,
+        columnSpacing: columns.spacing,
+        columnSeparator: columns.separator,
+        columnLayout: serializeDocumentColumns(columns),
+        breakAfter: validBreakType(layout.breakAfter),
+        headerText: legacy.headerText ?? '',
+        footerText: legacy.footerText ?? '',
+        showPageNumbers: Boolean(legacy.showPageNumbers),
+        pageNumberStart: validPageNumber(layout.pageNumberStart) ?? null,
+        pageChrome: serializeDocumentPageChrome(pageChrome)
+    };
+}
+function documentSectionLayoutFromNodeAttributes(attributes, fallback) {
+    const base = fallback ?? {
+        pageSize: 'a4',
+        orientation: 'portrait',
+        margins: {
+            top: 25,
+            right: 23,
+            bottom: 25,
+            left: 23
+        },
+        columns: DEFAULT_DOCUMENT_COLUMNS,
+        breakAfter: 'nextPage'
+    };
+    const pageChrome = parseDocumentPageChrome(attributes.pageChrome, {
+        headerText: attributes.headerText,
+        footerText: attributes.footerText,
+        showPageNumbers: attributes.showPageNumbers
+    }, base.pageChrome);
+    const legacy = documentPageChromeLegacyFields(pageChrome);
+    return {
+        pageSize: 'letter' === attributes.pageSize ? 'letter' : 'a4' === attributes.pageSize ? 'a4' : base.pageSize,
+        orientation: 'landscape' === attributes.orientation ? 'landscape' : 'portrait' === attributes.orientation ? 'portrait' : base.orientation,
+        margins: {
+            top: clampDocumentMargin(work_document_section_finiteNumber(attributes.marginTop, base.margins.top)),
+            right: clampDocumentMargin(work_document_section_finiteNumber(attributes.marginRight, base.margins.right)),
+            bottom: clampDocumentMargin(work_document_section_finiteNumber(attributes.marginBottom, base.margins.bottom)),
+            left: clampDocumentMargin(work_document_section_finiteNumber(attributes.marginLeft, base.margins.left))
+        },
+        columns: parseDocumentColumns(attributes.columnLayout, {
+            count: attributes.columnCount,
+            spacing: attributes.columnSpacing,
+            separator: attributes.columnSeparator
+        }, base.columns),
+        breakAfter: validBreakType(attributes.breakAfter ?? base.breakAfter),
+        headerText: legacy.headerText,
+        footerText: legacy.footerText,
+        showPageNumbers: legacy.showPageNumbers,
+        pageNumberStart: validPageNumber(attributes.pageNumberStart ?? void 0),
+        pageChrome
+    };
+}
+function documentSectionDomAttributes(layout, id) {
+    const attributes = documentSectionNodeAttributes(layout, id);
+    return {
+        'data-document-section': 'true',
+        'data-section-id': attributes.id,
+        'data-section-page-size': attributes.pageSize,
+        'data-section-orientation': attributes.orientation,
+        'data-section-margin-top': String(attributes.marginTop),
+        'data-section-margin-right': String(attributes.marginRight),
+        'data-section-margin-bottom': String(attributes.marginBottom),
+        'data-section-margin-left': String(attributes.marginLeft),
+        'data-section-column-count': String(attributes.columnCount),
+        'data-section-column-spacing': String(attributes.columnSpacing),
+        'data-section-column-separator': String(attributes.columnSeparator),
+        'data-section-column-layout': attributes.columnLayout,
+        'data-section-break-after': attributes.breakAfter,
+        'data-section-header-text': attributes.headerText,
+        'data-section-footer-text': attributes.footerText,
+        'data-section-show-page-numbers': String(attributes.showPageNumbers),
+        'data-section-page-number-start': null === attributes.pageNumberStart ? '' : String(attributes.pageNumberStart),
+        'data-section-page-chrome': attributes.pageChrome
+    };
+}
+function documentSectionLayoutFromElement(element, fallback) {
+    return documentSectionLayoutFromNodeAttributes({
+        pageSize: element.dataset.sectionPageSize,
+        orientation: element.dataset.sectionOrientation,
+        marginTop: numberValue(element.dataset.sectionMarginTop),
+        marginRight: numberValue(element.dataset.sectionMarginRight),
+        marginBottom: numberValue(element.dataset.sectionMarginBottom),
+        marginLeft: numberValue(element.dataset.sectionMarginLeft),
+        columnCount: numberValue(element.dataset.sectionColumnCount),
+        columnSpacing: numberValue(element.dataset.sectionColumnSpacing),
+        columnSeparator: 'true' === element.dataset.sectionColumnSeparator,
+        columnLayout: element.dataset.sectionColumnLayout ?? '',
+        breakAfter: element.dataset.sectionBreakAfter,
+        headerText: element.dataset.sectionHeaderText ?? '',
+        footerText: element.dataset.sectionFooterText ?? '',
+        showPageNumbers: 'true' === element.dataset.sectionShowPageNumbers,
+        pageNumberStart: numberValue(element.dataset.sectionPageNumberStart) ?? null,
+        pageChrome: element.dataset.sectionPageChrome ?? ''
+    }, fallback);
+}
+function syncDocumentContentFromHtml(content, html) {
+    const normalized = normalizeDocumentHtml({
+        ...content,
+        html
+    });
+    const first = documentSections({
+        ...content,
+        html: normalized
+    })[0]?.layout ?? documentInitialSectionLayout(content);
+    const nextContent = {
+        ...content
+    };
+    const model = documentModelForHtml(content.model, normalized);
+    if (model) nextContent.model = model;
+    else delete nextContent.model;
+    return {
+        ...nextContent,
+        html: normalized,
+        pageSize: first.pageSize,
+        orientation: first.orientation,
+        margins: first.margins,
+        columns: first.columns,
+        headerText: first.headerText,
+        footerText: first.footerText,
+        showPageNumbers: first.showPageNumbers,
+        pageNumberStart: first.pageNumberStart,
+        pageChrome: first.pageChrome
+    };
+}
+function documentContentLayoutProperties(layout) {
+    return {
+        pageSize: layout.pageSize,
+        orientation: layout.orientation,
+        margins: layout.margins,
+        columns: layout.columns,
+        headerText: layout.headerText,
+        footerText: layout.footerText,
+        showPageNumbers: layout.showPageNumbers,
+        pageNumberStart: layout.pageNumberStart,
+        pageChrome: layout.pageChrome
+    };
+}
+function normalizeDocumentSemanticHtml(source, bibliography) {
+    return normalizeDocumentCitationsHtml(normalizeDocumentFieldsHtml(normalizeDocumentCaptionsHtml(normalizeDocumentNotesHtml(source))), bibliography);
+}
+function applyDocumentSectionDomAttributes(element, layout, id) {
+    for (const [name, value] of Object.entries(documentSectionDomAttributes(layout, id)))element.setAttribute(name, value);
+}
+function validBreakType(value) {
+    if ('continuous' === value || 'evenPage' === value || 'oddPage' === value || 'nextColumn' === value) return value;
+    return 'nextPage';
+}
+function validPageNumber(value) {
+    return Number.isFinite(value) && Number(value) > 0 ? Math.min(9999, Math.round(Number(value))) : void 0;
+}
+function work_document_section_finiteNumber(value, fallback) {
+    return Number.isFinite(value) ? Number(value) : fallback;
+}
+function numberValue(value) {
+    if (!value?.trim()) return;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+}
+export { clampDocumentMargin, collectDocumentNotes, createDocumentBibliography, createDocumentNoteElement, createWorkDocumentModel, documentCaptionDisplay, documentCaptionKind, documentCaptionLabel, documentCitationInstruction, documentCitationStyle, documentCitationStyleDetails, documentCitationTags, documentCitationTagsFromInstruction, documentContentLayoutProperties, documentFieldDisplay, documentFieldInstruction, documentFieldKind, documentFieldLabel, documentHtmlFingerprint, documentInitialSectionLayout, documentMargins, documentModelForContent, documentNoteKey, documentNoteKind, documentNoteReferenceKeys, documentPageChromeLegacyFields, documentSectionDomAttributes, documentSectionLayoutFromNodeAttributes, documentSectionNodeAttributes, documentSections, docxDocumentFieldKind, isValidDocumentCitationTag, millimetersToPixels, normalizeDocumentCaptionsHtml, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentFieldsHtml, normalizeDocumentHtml, normalizeDocumentNotesHtml, normalizeDocumentPageChrome, removeDocumentNoteDefinitions, renameDocumentCitationTagInInstruction, renderDocumentBibliographyHtml, resolveDocumentCitation, resolveDocumentFieldsHtml, resolveDocumentPageChrome, resolveWorkDocumentEditorInput, sanitizeDocumentPageChromeHtml, setCustomDocumentColumns, syncDocumentContentFromHtml, updateDocumentColumnWidth, updateDocumentPageChromeVariant };