@a3s-lab/office 0.1.0

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

@@ -0,0 +1,1151 @@
+import { normalizeDocumentTableLayoutMode, normalizeDocumentTableRowHeightRule, normalizeTableColor, normalizeDocumentTableBorderWidth, normalizeDocumentTableVerticalAlign, normalizeDocumentTableBorderStyle } from "./0~6552.js";
+import { documentCitationTags, documentNoteKind, documentSections, documentCaptionLabel, documentCaptionKind, collectDocumentNotes, documentNoteKey, normalizeDocumentPageChrome, normalizeDocumentColumns, documentCitationInstruction, docxDocumentFieldKind } from "./4704.js";
+import { documentImageLayoutFromElement, normalizeDocumentTabStops } from "./0~8155.js";
+import { patchDocxBibliography } from "./0~work-docx-bibliography.js";
+import { patchDocxPageColor } from "./0~work-docx-page-color.js";
+function documentTableCellDocxOptions(cell, docx) {
+    const backgroundColor = normalizeTableColor(cell.dataset.officeCellFill || cell.style.backgroundColor);
+    const verticalAlign = normalizeDocumentTableVerticalAlign(cell.dataset.officeCellVerticalAlign || cell.style.verticalAlign);
+    const borderStyle = normalizeDocumentTableBorderStyle(cell.dataset.officeCellBorderStyle || cell.style.borderStyle);
+    const borderWidth = normalizeDocumentTableBorderWidth(cell.dataset.officeCellBorderWidth || cell.style.borderWidth);
+    const borderColor = normalizeTableColor(cell.dataset.officeCellBorderColor || cell.style.borderColor);
+    const border = borderStyle ? {
+        style: docxBorderStyle(borderStyle, docx),
+        ...'none' === borderStyle ? {} : {
+            color: docxColor(borderColor ?? '#cfd5df'),
+            size: Math.max(1, Math.round((borderWidth ?? 1) * 6))
+        }
+    } : null;
+    return {
+        ...backgroundColor ? {
+            shading: {
+                fill: docxColor(backgroundColor),
+                type: docx.ShadingType.CLEAR
+            }
+        } : {},
+        ...verticalAlign ? {
+            verticalAlign: 'middle' === verticalAlign ? docx.VerticalAlignTable.CENTER : 'bottom' === verticalAlign ? docx.VerticalAlignTable.BOTTOM : docx.VerticalAlignTable.TOP
+        } : {},
+        ...border ? {
+            borders: {
+                top: border,
+                right: border,
+                bottom: border,
+                left: border
+            }
+        } : {}
+    };
+}
+function docxBorderStyle(style, docx) {
+    if ('dashed' === style) return docx.BorderStyle.DASHED;
+    if ('dotted' === style) return docx.BorderStyle.DOTTED;
+    if ('double' === style) return docx.BorderStyle.DOUBLE;
+    if ('none' === style) return docx.BorderStyle.NONE;
+    return docx.BorderStyle.SINGLE;
+}
+function docxColor(color) {
+    return color.replace(/^#/, '').toUpperCase();
+}
+const TWIPS_PER_PIXEL = 15;
+function documentTableSizingDocxOptions(table, docx) {
+    const mode = normalizeDocumentTableLayoutMode(table.dataset.officeTableLayout);
+    const pixelWidths = documentTableColumnWidths(table);
+    const columnWidths = pixelWidths?.map(pixelsToTwips);
+    if ('contents' === mode) return {
+        layout: docx.TableLayoutType.AUTOFIT,
+        width: {
+            size: 0,
+            type: docx.WidthType.AUTO
+        }
+    };
+    if ('fixed' === mode && columnWidths?.length) return {
+        columnWidths,
+        layout: docx.TableLayoutType.FIXED,
+        width: {
+            size: columnWidths.reduce((sum, width)=>sum + width, 0),
+            type: docx.WidthType.DXA
+        }
+    };
+    return {
+        layout: docx.TableLayoutType.FIXED,
+        width: {
+            size: 100,
+            type: docx.WidthType.PERCENTAGE
+        }
+    };
+}
+function documentTableCellSizingDocxOptions(cell, docx) {
+    const widths = cellColumnWidths(cell);
+    if (!widths?.length) return {};
+    return {
+        width: {
+            size: pixelsToTwips(widths.reduce((sum, width)=>sum + width, 0)),
+            type: docx.WidthType.DXA
+        }
+    };
+}
+function documentTableRowSizingDocxOptions(row, docx) {
+    const pixels = rowHeightPixels(row);
+    if (null === pixels) return {};
+    const rule = normalizeDocumentTableRowHeightRule(row.dataset.officeRowHeightRule);
+    return {
+        height: {
+            value: pixelsToTwips(pixels),
+            rule: 'exact' === rule ? docx.HeightRule.EXACT : docx.HeightRule.ATLEAST
+        }
+    };
+}
+function documentTableColumnWidths(table) {
+    const row = table.rows[0];
+    if (!row) return null;
+    const widths = [];
+    for (const cell of Array.from(row.cells)){
+        const cellWidths = cellColumnWidths(cell);
+        if (!cellWidths || cellWidths.length !== cell.colSpan) return null;
+        widths.push(...cellWidths);
+    }
+    return widths.length ? widths : null;
+}
+function cellColumnWidths(cell) {
+    const raw = cell.getAttribute('colwidth') ?? cell.dataset.colwidth;
+    if (!raw) return null;
+    const widths = raw.split(',').map((width)=>Number(width)).filter((width)=>Number.isFinite(width) && width > 0);
+    return widths.length === cell.colSpan ? widths : null;
+}
+function rowHeightPixels(row) {
+    const value = Number.parseFloat(row.dataset.officeRowHeight || row.style.height);
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+function pixelsToTwips(pixels) {
+    return Math.max(1, Math.round(pixels * TWIPS_PER_PIXEL));
+}
+function docxCaptionParagraph(element, titleChildren, docx, bidirectional) {
+    const kind = documentCaptionKind(element.dataset.captionKind) ?? 'figure';
+    const number = positiveInteger(element.dataset.captionNumber);
+    const bookmarkId = docxCaptionBookmarkId(element.dataset.captionId ?? `${kind}-${number}`);
+    return new docx.Paragraph({
+        bidirectional,
+        alignment: docx.AlignmentType.CENTER,
+        spacing: {
+            after: 160,
+            line: 300
+        },
+        children: [
+            new docx.TextRun(`${documentCaptionLabel(kind)} `),
+            new docx.Bookmark({
+                id: bookmarkId,
+                children: [
+                    new docx.SequentialIdentifier('table' === kind ? 'Table' : 'Figure')
+                ]
+            }),
+            new docx.TextRun('　'),
+            ...titleChildren
+        ]
+    });
+}
+function docxCrossReferenceRuns(element, docx) {
+    if ('true' === element.dataset.referenceOrphaned) return [
+        new docx.TextRun('引用缺失')
+    ];
+    const kind = documentCaptionKind(element.dataset.captionKind) ?? 'figure';
+    const number = positiveInteger(element.dataset.captionNumber);
+    const targetId = element.dataset.referenceTargetId?.trim();
+    if (!targetId) return [
+        new docx.TextRun('引用缺失')
+    ];
+    return [
+        new docx.TextRun(`${documentCaptionLabel(kind)} `),
+        new docx.NumberedItemReference(docxCaptionBookmarkId(targetId), String(number), {
+            hyperlink: true,
+            referenceFormat: docx.NumberedItemReferenceFormat.NONE
+        })
+    ];
+}
+function docxCaptionBookmarkId(source) {
+    const safe = source.replace(/[^a-z0-9_]/gi, '_').replace(/^([^a-z_])/i, '_$1').slice(0, 18);
+    return `A3SCaption_${safe || 'item'}_${stableHash(source)}`.slice(0, 40);
+}
+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(36);
+}
+function positiveInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : 1;
+}
+function docxCitationRun(element, docx) {
+    const tags = documentCitationTags(element.dataset.citationTags);
+    const instruction = element.dataset.citationInstruction?.trim() || documentCitationInstruction(tags);
+    const display = element.dataset.citationDisplay?.trim() || element.textContent?.trim() || '缺失引文';
+    if (!tags.length || !/^\s*CITATION\b/i.test(instruction)) return new docx.TextRun(display);
+    return new docx.SimpleField(instruction, display);
+}
+function docxBibliographyParagraph(element, docx, bidirectional) {
+    const instruction = element.dataset.bibliographyInstruction?.trim() || 'BIBLIOGRAPHY \\l 2052';
+    const cached = Array.from(element.querySelectorAll('[data-bibliography-entry]')).map((entry)=>entry.textContent?.trim() ?? '').filter(Boolean).join('\n');
+    return new docx.Paragraph({
+        bidirectional,
+        children: [
+            new docx.SimpleField(instruction, cached || '参考文献')
+        ],
+        spacing: {
+            before: 240,
+            after: 120,
+            line: 320
+        }
+    });
+}
+const MIN_COLUMN_WIDTH_TWIPS = 240;
+function docxSectionColumns(layout, pageWidth, docx) {
+    const columns = normalizeDocumentColumns(layout.columns);
+    if (!columns.custom) return {
+        count: columns.count,
+        space: millimetersToTwips(columns.spacing),
+        separate: columns.separator,
+        equalWidth: true
+    };
+    const contentWidth = Math.max(columns.count * MIN_COLUMN_WIDTH_TWIPS, pageWidth - millimetersToTwips(layout.margins.left + layout.margins.right));
+    const requestedSpaces = columns.custom.slice(0, -1).map((column)=>millimetersToTwips(column.spacing));
+    const maximumSpaceWidth = Math.max(0, contentWidth - columns.count * MIN_COLUMN_WIDTH_TWIPS);
+    const requestedSpaceWidth = requestedSpaces.reduce((total, value)=>total + value, 0);
+    const spaceScale = requestedSpaceWidth > maximumSpaceWidth ? maximumSpaceWidth / requestedSpaceWidth : 1;
+    const spaces = requestedSpaces.map((space)=>Math.round(space * spaceScale));
+    const availableWidth = contentWidth - spaces.reduce((total, value)=>total + value, 0);
+    const widths = columns.custom.map((column)=>Math.round(availableWidth * column.widthPercent / 100));
+    widths[widths.length - 1] += availableWidth - widths.reduce((total, value)=>total + value, 0);
+    return {
+        count: columns.count,
+        separate: columns.separator,
+        equalWidth: false,
+        children: columns.custom.map((_, index)=>new docx.Column({
+                width: Math.max(MIN_COLUMN_WIDTH_TWIPS, widths[index]),
+                space: index < spaces.length ? spaces[index] : void 0
+            }))
+    };
+}
+function millimetersToTwips(value) {
+    return Math.round(1440 * value / 25.4);
+}
+function docxDocumentFieldRun(element, docx) {
+    const instruction = element.dataset.fieldInstruction?.trim() ?? '';
+    const display = element.dataset.fieldDisplay?.trim() || element.textContent?.trim() || '';
+    if (!docxDocumentFieldKind(instruction)) return new docx.TextRun(display);
+    return new docx.SimpleField(instruction, display);
+}
+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) {
+    return {
+        keepLines: dataBoolean(element.dataset.officeKeepLines),
+        keepNext: dataBoolean(element.dataset.officeKeepWithNext),
+        pageBreakBefore: dataBoolean(element.dataset.officePageBreakBefore),
+        widowControl: dataBoolean(element.dataset.officeWidowControl)
+    };
+}
+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();
+}
+async function imageToDocx(element, docx) {
+    const source = element.getAttribute('src');
+    const alt = element.getAttribute('alt') || element.getAttribute('title') || 'Image';
+    if (!source) return new docx.TextRun(`[${alt}]`);
+    try {
+        const blob = await fetch(source).then((response)=>{
+            if (!response.ok) throw new Error(`Image request failed with HTTP ${response.status}`);
+            return response.blob();
+        });
+        const type = docxImageType(blob.type, source);
+        if (!type) return new docx.TextRun(`[${alt}]`);
+        const dimensions = element.width > 0 && element.height > 0 ? {
+            width: element.width,
+            height: element.height
+        } : await imageDimensions(blob);
+        const maximumWidth = 520;
+        const scale = Math.min(1, maximumWidth / Math.max(1, dimensions.width));
+        return new docx.ImageRun({
+            type,
+            data: await blob.arrayBuffer(),
+            transformation: {
+                width: Math.max(24, Math.round(dimensions.width * scale)),
+                height: Math.max(24, Math.round(dimensions.height * scale))
+            },
+            altText: {
+                name: alt,
+                description: alt,
+                title: alt
+            },
+            floating: documentImageFloatingOptions(element, docx)
+        });
+    } catch  {
+        return new docx.TextRun(`[${alt}]`);
+    }
+}
+function documentImageFloatingOptions(element, docx) {
+    const image = documentImageLayoutFromElement(element);
+    if ('inline' === image.layout) return;
+    const distance = Math.round(36000 * image.wrapDistance);
+    const align = 'left' === image.alignment ? docx.HorizontalPositionAlign.LEFT : 'right' === image.alignment ? docx.HorizontalPositionAlign.RIGHT : docx.HorizontalPositionAlign.CENTER;
+    return {
+        horizontalPosition: {
+            relative: docx.HorizontalPositionRelativeFrom.COLUMN,
+            align
+        },
+        verticalPosition: {
+            relative: docx.VerticalPositionRelativeFrom.PARAGRAPH,
+            offset: 0
+        },
+        allowOverlap: false,
+        behindDocument: false,
+        layoutInCell: true,
+        lockAnchor: false,
+        margins: {
+            top: distance,
+            right: distance,
+            bottom: distance,
+            left: distance
+        },
+        wrap: {
+            type: 'square' === image.layout ? docx.TextWrappingType.SQUARE : docx.TextWrappingType.TOP_AND_BOTTOM,
+            ...'square' === image.layout ? {
+                side: docx.TextWrappingSide.BOTH_SIDES
+            } : {}
+        }
+    };
+}
+function docxImageType(contentType, source) {
+    const value = `${contentType} ${source}`.toLowerCase();
+    if (value.includes('png')) return 'png';
+    if (value.includes('jpeg') || value.includes('jpg')) return 'jpg';
+    if (value.includes('gif')) return 'gif';
+    if (value.includes('bmp')) return 'bmp';
+    return null;
+}
+function imageDimensions(blob) {
+    return new Promise((resolve, reject)=>{
+        const url = URL.createObjectURL(blob);
+        const image = new window.Image();
+        image.addEventListener('load', ()=>{
+            URL.revokeObjectURL(url);
+            resolve({
+                width: image.naturalWidth || 640,
+                height: image.naturalHeight || 360
+            });
+        }, {
+            once: true
+        });
+        image.addEventListener('error', ()=>{
+            URL.revokeObjectURL(url);
+            reject(new Error('Image dimensions could not be read'));
+        }, {
+            once: true
+        });
+        image.src = url;
+    });
+}
+async function createDocxBlob(content) {
+    const docx = await import("docx");
+    const noteCollection = collectDocumentNotes(content.html);
+    const comments = anchoredDocumentComments(content);
+    const noteContext = {
+        ids: new Map(noteCollection.notes.map((note)=>[
+                documentNoteKey(note.kind, note.id),
+                note.number
+            ])),
+        changeIds: new Map(),
+        nextChangeId: 1,
+        commentIds: new Map(),
+        commentRangeCounts: documentCommentRangeCounts(content.html),
+        commentRangeSeen: new Map(),
+        numbering: [],
+        nextNumberingReference: 1
+    };
+    const commentRecords = createDocxCommentRecords(comments, docx, noteContext);
+    const sections = [];
+    let usesOddEvenPageChrome = false;
+    for (const section of documentSections({
+        ...content,
+        html: noteCollection.html
+    })){
+        const parsed = new DOMParser().parseFromString(section.html, 'text/html');
+        const children = [];
+        for (const node of parsed.body.children){
+            const element = node;
+            if (!element.hasAttribute('data-document-note')) children.push(...await blockToFileChildren(element, docx, noteContext));
+        }
+        if (!children.length) children.push(new docx.Paragraph(''));
+        const pageChrome = normalizeDocumentPageChrome(section.layout.pageChrome, section.layout);
+        usesOddEvenPageChrome ||= pageChrome.differentOddEvenPages;
+        const headers = await sectionHeaders(pageChrome, docx, noteContext);
+        const footers = await sectionFooters(pageChrome, docx, noteContext);
+        sections.push({
+            properties: sectionProperties(section.layout, docx),
+            headers,
+            footers,
+            children
+        });
+    }
+    const footnotes = await createNoteRecords(noteCollection.notes, 'footnote', docx, noteContext);
+    const endnotes = await createNoteRecords(noteCollection.notes, 'endnote', docx, noteContext);
+    const document = new docx.Document({
+        sections,
+        footnotes: Object.keys(footnotes).length ? footnotes : void 0,
+        endnotes: Object.keys(endnotes).length ? endnotes : void 0,
+        comments: commentRecords.length ? {
+            children: commentRecords
+        } : void 0,
+        numbering: noteContext.numbering.length ? {
+            config: noteContext.numbering
+        } : void 0,
+        evenAndOddHeaderAndFooters: usesOddEvenPageChrome,
+        features: {
+            trackRevisions: Boolean(content.trackChanges || documentHasTrackedChanges(content.html)),
+            updateFields: true
+        }
+    });
+    const packed = await docx.Packer.toBlob(document);
+    const bibliographyPatched = await patchDocxBibliography(await packed.arrayBuffer(), content.bibliography);
+    const patched = await patchDocxPageColor(bibliographyPatched, content.pageColor);
+    return new Blob([
+        patched
+    ], {
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+    });
+}
+function sectionProperties(layout, docx) {
+    const landscape = 'landscape' === layout.orientation;
+    const dimensions = 'letter' === layout.pageSize ? {
+        width: landscape ? 15840 : 12240,
+        height: landscape ? 12240 : 15840
+    } : {
+        width: landscape ? 16838 : 11906,
+        height: landscape ? 11906 : 16838
+    };
+    return {
+        type: docxSectionType(layout.breakAfter, docx),
+        titlePage: normalizeDocumentPageChrome(layout.pageChrome, layout).differentFirstPage,
+        page: {
+            size: {
+                ...dimensions,
+                orientation: landscape ? docx.PageOrientation.LANDSCAPE : docx.PageOrientation.PORTRAIT
+            },
+            margin: {
+                top: work_docx_export_millimetersToTwips(layout.margins.top),
+                right: work_docx_export_millimetersToTwips(layout.margins.right),
+                bottom: work_docx_export_millimetersToTwips(layout.margins.bottom),
+                left: work_docx_export_millimetersToTwips(layout.margins.left)
+            },
+            pageNumbers: layout.pageNumberStart ? {
+                start: layout.pageNumberStart
+            } : void 0
+        },
+        column: docxSectionColumns(layout, dimensions.width, docx)
+    };
+}
+async function sectionHeaders(chrome, docx, noteContext) {
+    const headers = {};
+    const defaultHeader = await headerFromHtml(chrome.default.headerHtml, docx, noteContext);
+    if (defaultHeader) headers.default = defaultHeader;
+    if (chrome.differentFirstPage) {
+        const firstHeader = await headerFromHtml(chrome.first.headerHtml, docx, noteContext);
+        if (firstHeader) headers.first = firstHeader;
+    }
+    if (chrome.differentOddEvenPages) {
+        const evenHeader = await headerFromHtml(chrome.even.headerHtml, docx, noteContext);
+        if (evenHeader) headers.even = evenHeader;
+    }
+    return Object.keys(headers).length ? headers : void 0;
+}
+async function sectionFooters(chrome, docx, noteContext) {
+    const footers = {};
+    const defaultFooter = await footerFromContent(chrome.default, docx, noteContext);
+    if (defaultFooter) footers.default = defaultFooter;
+    if (chrome.differentFirstPage) {
+        const firstFooter = await footerFromContent(chrome.first, docx, noteContext);
+        if (firstFooter) footers.first = firstFooter;
+    }
+    if (chrome.differentOddEvenPages) {
+        const evenFooter = await footerFromContent(chrome.even, docx, noteContext);
+        if (evenFooter) footers.even = evenFooter;
+    }
+    return Object.keys(footers).length ? footers : void 0;
+}
+async function headerFromHtml(html, docx, noteContext) {
+    const children = await pageChromeBlocks(html, docx, noteContext);
+    return children.length ? new docx.Header({
+        children
+    }) : void 0;
+}
+async function footerFromContent(content, docx, noteContext) {
+    const children = await pageChromeBlocks(content.footerHtml, docx, noteContext);
+    if (content.showPageNumber) children.push(new docx.Paragraph({
+        alignment: docx.AlignmentType.CENTER,
+        children: [
+            new docx.TextRun({
+                children: [
+                    docx.PageNumber.CURRENT
+                ]
+            })
+        ]
+    }));
+    return children.length ? new docx.Footer({
+        children
+    }) : void 0;
+}
+function docxSectionType(type, docx) {
+    if ('continuous' === type) return docx.SectionType.CONTINUOUS;
+    if ('evenPage' === type) return docx.SectionType.EVEN_PAGE;
+    if ('oddPage' === type) return docx.SectionType.ODD_PAGE;
+    if ('nextColumn' === type) return docx.SectionType.NEXT_COLUMN;
+    return docx.SectionType.NEXT_PAGE;
+}
+async function blockToFileChildren(element, docx, noteContext) {
+    const tag = element.tagName.toLowerCase();
+    if (element.hasAttribute('data-page-break')) return [
+        new docx.Paragraph({
+            children: [
+                new docx.PageBreak()
+            ]
+        })
+    ];
+    if (element.hasAttribute('data-document-bibliography')) return [
+        docxBibliographyParagraph(element, docx, paragraphBidirectional(element))
+    ];
+    if (element.hasAttribute('data-document-caption')) return [
+        docxCaptionParagraph(element, await inlineRuns(element, docx, noteContext), docx, paragraphBidirectional(element))
+    ];
+    if ('table' === tag) return [
+        await tableToDocx(element, docx, noteContext)
+    ];
+    if ('img' === tag) return [
+        new docx.Paragraph({
+            children: [
+                await imageToDocx(element, docx)
+            ]
+        })
+    ];
+    if ('ul' === tag || 'ol' === tag) return listToDocxParagraphs(element, docx, noteContext);
+    const runs = await inlineRuns(element, docx, noteContext);
+    const heading = 'h1' === tag ? docx.HeadingLevel.HEADING_1 : 'h2' === tag ? docx.HeadingLevel.HEADING_2 : 'h3' === tag ? docx.HeadingLevel.HEADING_3 : void 0;
+    return [
+        new docx.Paragraph({
+            children: runs.length ? runs : [
+                new docx.TextRun('')
+            ],
+            heading,
+            alignment: paragraphAlignment(element, docx),
+            spacing: paragraphSpacingOptions(element, Boolean(heading), docx),
+            indent: paragraphIndent(element, tag),
+            tabStops: paragraphTabStops(element, docx),
+            ...paragraphPaginationOptions(element),
+            ...paragraphDirectionOptions(element)
+        })
+    ];
+}
+async function listToDocxParagraphs(list, docx, noteContext, depth = 0) {
+    const paragraphs = [];
+    const level = Math.min(8, Math.max(0, depth));
+    const ordered = 'ol' === list.tagName.toLowerCase();
+    const numbering = ordered ? registerOrderedListNumbering(list, level, docx, noteContext) : registerBulletListNumbering(list, level, docx, noteContext);
+    const items = Array.from(list.children).filter((child)=>child instanceof HTMLElement && 'li' === child.tagName.toLowerCase());
+    for (const item of items){
+        const directBlocks = Array.from(item.children).filter((child)=>child instanceof HTMLElement && 'ol' !== child.tagName.toLowerCase() && 'ul' !== child.tagName.toLowerCase());
+        const contentBlocks = directBlocks.length ? directBlocks : [
+            directListItemContentRoot(item)
+        ];
+        for (const [blockIndex, block] of contentBlocks.entries()){
+            const tag = block.tagName.toLowerCase();
+            const heading = 'h1' === tag ? docx.HeadingLevel.HEADING_1 : 'h2' === tag ? docx.HeadingLevel.HEADING_2 : 'h3' === tag ? docx.HeadingLevel.HEADING_3 : void 0;
+            const runs = await inlineRuns(block, docx, noteContext);
+            paragraphs.push(new docx.Paragraph({
+                children: runs.length ? runs : [
+                    new docx.TextRun('')
+                ],
+                heading,
+                ...0 === blockIndex ? {
+                    numbering
+                } : {
+                    indent: paragraphIndent(block, tag) ?? {
+                        left: (level + 1) * 720
+                    }
+                },
+                alignment: paragraphAlignment(block, docx),
+                spacing: paragraphSpacingOptions(block, Boolean(heading), docx),
+                ...0 === blockIndex ? {
+                    indent: paragraphIndent(block, tag)
+                } : {},
+                tabStops: paragraphTabStops(block, docx),
+                ...paragraphPaginationOptions(block),
+                ...paragraphDirectionOptions(block)
+            }));
+        }
+        for (const nested of Array.from(item.children).filter((child)=>child instanceof HTMLElement && ('ol' === child.tagName.toLowerCase() || 'ul' === child.tagName.toLowerCase())))paragraphs.push(...await listToDocxParagraphs(nested, docx, noteContext, depth + 1));
+    }
+    return paragraphs;
+}
+function registerOrderedListNumbering(list, level, docx, noteContext) {
+    const reference = `a3s-office-list-${noteContext.nextNumberingReference}`;
+    noteContext.nextNumberingReference += 1;
+    noteContext.numbering.push({
+        reference,
+        levels: Array.from({
+            length: 9
+        }, (_, currentLevel)=>({
+                level: currentLevel,
+                format: currentLevel === level ? orderedListLevelFormat(list, currentLevel, docx) : defaultOrderedListLevelFormat(currentLevel, docx),
+                text: `%${currentLevel + 1}.`,
+                start: currentLevel === level ? orderedListStart(list) : 1,
+                suffix: docx.LevelSuffix.TAB,
+                style: {
+                    paragraph: {
+                        indent: {
+                            left: (currentLevel + 1) * 720,
+                            hanging: 360
+                        }
+                    }
+                }
+            }))
+    });
+    return {
+        reference,
+        level
+    };
+}
+function registerBulletListNumbering(list, level, docx, noteContext) {
+    const reference = `a3s-office-list-${noteContext.nextNumberingReference}`;
+    noteContext.nextNumberingReference += 1;
+    noteContext.numbering.push({
+        reference,
+        levels: Array.from({
+            length: 9
+        }, (_, currentLevel)=>({
+                level: currentLevel,
+                format: docx.LevelFormat.BULLET,
+                text: currentLevel === level ? bulletListMarker(list) : defaultBulletListMarker(currentLevel),
+                start: 1,
+                suffix: docx.LevelSuffix.TAB,
+                style: {
+                    paragraph: {
+                        indent: {
+                            left: (currentLevel + 1) * 720,
+                            hanging: 360
+                        }
+                    }
+                }
+            }))
+    });
+    return {
+        reference,
+        level
+    };
+}
+function orderedListLevelFormat(list, level, docx) {
+    const type = list.getAttribute('type');
+    if ('A' === type) return docx.LevelFormat.UPPER_LETTER;
+    if ('a' === type) return docx.LevelFormat.LOWER_LETTER;
+    if ('I' === type) return docx.LevelFormat.UPPER_ROMAN;
+    if ('i' === type) return docx.LevelFormat.LOWER_ROMAN;
+    return defaultOrderedListLevelFormat(level, docx);
+}
+function defaultOrderedListLevelFormat(level, docx) {
+    if (level % 3 === 1) return docx.LevelFormat.LOWER_LETTER;
+    if (level % 3 === 2) return docx.LevelFormat.LOWER_ROMAN;
+    return docx.LevelFormat.DECIMAL;
+}
+function orderedListStart(list) {
+    const value = Number(list.getAttribute('start'));
+    return Number.isSafeInteger(value) && value > 0 ? Math.min(value, 2147483647) : 1;
+}
+function bulletListMarker(list) {
+    const style = list.dataset.officeBulletStyle || list.style.listStyleType || 'disc';
+    if ('circle' === style) return '○';
+    if ('square' === style) return '■';
+    return '●';
+}
+function defaultBulletListMarker(level) {
+    if (level % 3 === 1) return '○';
+    if (level % 3 === 2) return '■';
+    return '●';
+}
+function directListItemContentRoot(item) {
+    const root = item.ownerDocument.createElement('span');
+    const direction = item.getAttribute('dir');
+    if (direction) root.setAttribute('dir', direction);
+    for (const child of item.childNodes)if (!(child instanceof HTMLElement) || 'ol' !== child.tagName.toLowerCase() && 'ul' !== child.tagName.toLowerCase()) root.append(child.cloneNode(true));
+    return root;
+}
+function work_docx_export_millimetersToTwips(value) {
+    return Math.round(1440 * value / 25.4);
+}
+async function pageChromeBlocks(html, docx, noteContext) {
+    if (!html.trim()) return [];
+    const document = new DOMParser().parseFromString(html, 'text/html');
+    const children = [];
+    for (const element of Array.from(document.body.children)){
+        const blocks = await blockToFileChildren(element, docx, noteContext);
+        for (const block of blocks)if (block instanceof docx.Paragraph || block instanceof docx.Table) children.push(block);
+    }
+    if (!children.length && document.body.textContent?.trim()) children.push(new docx.Paragraph({
+        children: await inlineRuns(document.body, docx, noteContext),
+        ...paragraphDirectionOptions(document.body)
+    }));
+    return children;
+}
+async function inlineRuns(root, docx, noteContext) {
+    const runs = [];
+    const visit = async (node, inherited = {}, revision)=>{
+        if (node.nodeType === Node.TEXT_NODE) {
+            if (!node.textContent) return [];
+            if (revision?.kind === 'insertion') return [
+                new docx.InsertedTextRun({
+                    ...inherited,
+                    id: revision.id,
+                    author: revision.author,
+                    date: revision.date,
+                    text: node.textContent
+                })
+            ];
+            if (revision?.kind === 'deletion') return [
+                new docx.DeletedTextRun({
+                    ...inherited,
+                    id: revision.id,
+                    author: revision.author,
+                    date: revision.date,
+                    text: node.textContent
+                })
+            ];
+            return [
+                new docx.TextRun({
+                    ...inherited,
+                    text: node.textContent
+                })
+            ];
+        }
+        if (!(node instanceof HTMLElement)) return [];
+        const tag = node.tagName.toLowerCase();
+        if (node.hasAttribute('data-document-tab')) return [
+            new docx.Tab()
+        ];
+        if (node.hasAttribute('data-document-citation')) return [
+            docxCitationRun(node, docx)
+        ];
+        if (node.hasAttribute('data-document-field')) return [
+            docxDocumentFieldRun(node, docx)
+        ];
+        if (node.hasAttribute('data-document-cross-reference')) return docxCrossReferenceRuns(node, docx);
+        if (node.hasAttribute('data-document-note-reference')) {
+            const kind = documentNoteKind(node.dataset.noteKind);
+            const id = node.dataset.noteId?.trim();
+            const noteId = kind && id ? noteContext.ids.get(documentNoteKey(kind, id)) : void 0;
+            if (!kind || !noteId) return [];
+            return [
+                'footnote' === kind ? new docx.FootnoteReferenceRun(noteId) : new docx.EndnoteReferenceRun(noteId)
+            ];
+        }
+        const change = node.hasAttribute('data-document-change') ? docxTextRevision(node, 'del' === tag ? 'deletion' : 'insertion', noteContext) : revision;
+        const commentBoundary = node.hasAttribute('data-document-comment') ? nextDocxCommentBoundary(node.dataset.commentId, noteContext) : null;
+        const backgroundColor = cssColorToHex(node.style.backgroundColor);
+        const direction = domDirection(node);
+        const style = {
+            ...inherited,
+            bold: inherited.bold || 'strong' === tag || 'b' === tag,
+            italics: inherited.italics || 'em' === tag || 'i' === tag,
+            underline: inherited.underline || 'u' === tag ? {} : void 0,
+            strike: inherited.strike || 's' === tag || 'strike' === tag,
+            subScript: inherited.subScript || 'sub' === tag,
+            superScript: inherited.superScript || 'sup' === tag,
+            color: cssColorToHex(node.style.color) ?? inherited.color,
+            font: cssFontFamily(node.style.fontFamily) ?? inherited.font,
+            size: cssFontSize(node.style.fontSize) ?? inherited.size,
+            shading: backgroundColor ? {
+                fill: backgroundColor
+            } : inherited.shading,
+            rightToLeft: void 0 === direction ? inherited.rightToLeft : 'rtl' === direction
+        };
+        if ('br' === tag) return [
+            new docx.TextRun({
+                ...style,
+                break: 1
+            })
+        ];
+        if ('img' === tag) return [
+            await imageToDocx(node, docx)
+        ];
+        const children = [];
+        for (const child of node.childNodes)children.push(...await visit(child, style, change));
+        const result = 'a' === tag && node.getAttribute('href') ? [
+            new docx.ExternalHyperlink({
+                link: node.getAttribute('href') ?? '',
+                children
+            })
+        ] : children;
+        if (!commentBoundary) return result;
+        return [
+            ...commentBoundary.start ? [
+                new docx.CommentRangeStart(commentBoundary.id)
+            ] : [],
+            ...result,
+            ...commentBoundary.end ? [
+                new docx.CommentRangeEnd(commentBoundary.id),
+                new docx.CommentReference(commentBoundary.id)
+            ] : []
+        ];
+    };
+    const direction = domDirection(root);
+    const inheritedDirection = void 0 === direction ? {} : {
+        rightToLeft: 'rtl' === direction
+    };
+    for (const node of root.childNodes)runs.push(...await visit(node, inheritedDirection));
+    return runs;
+}
+function docxTextRevision(element, kind, context) {
+    const key = element.dataset.changeId?.trim() || `change-${context.nextChangeId}`;
+    let id = context.changeIds.get(key);
+    if (!id) {
+        id = context.nextChangeId;
+        context.nextChangeId += 1;
+        context.changeIds.set(key, id);
+    }
+    const sourceDate = element.dataset.changeDate?.trim() ?? '';
+    const time = Date.parse(sourceDate);
+    return {
+        kind,
+        id,
+        author: element.dataset.changeAuthor?.trim() || 'A3S Work',
+        date: Number.isFinite(time) ? new Date(time).toISOString() : new Date().toISOString()
+    };
+}
+function documentHasTrackedChanges(html) {
+    const document = new DOMParser().parseFromString(html, 'text/html');
+    return Boolean(document.body.querySelector('ins[data-document-change], del[data-document-change]'));
+}
+function anchoredDocumentComments(content) {
+    const document = new DOMParser().parseFromString(content.html, 'text/html');
+    const ids = Array.from(document.body.querySelectorAll('[data-document-comment][data-comment-id]')).map((element)=>element.dataset.commentId?.trim() ?? '').filter(Boolean);
+    const stored = new Map((content.comments ?? []).map((comment)=>[
+            comment.id,
+            comment
+        ]));
+    return Array.from(new Set(ids)).map((id)=>stored.get(id) ?? {
+            id,
+            author: '未知审阅者',
+            date: '',
+            text: '此批注的内容不可用。',
+            resolved: false
+        });
+}
+function documentCommentRangeCounts(html) {
+    const document = new DOMParser().parseFromString(html, 'text/html');
+    const counts = new Map();
+    for (const element of Array.from(document.body.querySelectorAll('[data-document-comment][data-comment-id]'))){
+        const id = element.dataset.commentId?.trim();
+        if (id) counts.set(id, (counts.get(id) ?? 0) + 1);
+    }
+    return counts;
+}
+function createDocxCommentRecords(comments, docx, context) {
+    const records = [];
+    let nextId = 0;
+    for (const comment of comments){
+        const id = nextId;
+        nextId += 1;
+        context.commentIds.set(comment.id, id);
+        records.push({
+            id,
+            author: comment.author || 'A3S Work',
+            initials: commentInitials(comment.author),
+            date: commentDate(comment.date),
+            resolved: Boolean(comment.resolved),
+            children: [
+                new docx.Paragraph({
+                    text: comment.text || '（空批注）'
+                })
+            ]
+        });
+        for (const reply of comment.replies ?? []){
+            records.push({
+                id: nextId,
+                parentId: id,
+                author: reply.author || 'A3S Work',
+                initials: commentInitials(reply.author),
+                date: commentDate(reply.date),
+                children: [
+                    new docx.Paragraph({
+                        text: reply.text || '（空回复）'
+                    })
+                ]
+            });
+            nextId += 1;
+        }
+    }
+    return records;
+}
+function nextDocxCommentBoundary(sourceId, context) {
+    const key = sourceId?.trim() ?? '';
+    const id = context.commentIds.get(key);
+    const count = context.commentRangeCounts.get(key) ?? 0;
+    if (void 0 === id || !count) return null;
+    const seen = (context.commentRangeSeen.get(key) ?? 0) + 1;
+    context.commentRangeSeen.set(key, seen);
+    return {
+        id,
+        start: 1 === seen,
+        end: seen === count
+    };
+}
+function commentDate(value) {
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time) : new Date();
+}
+function commentInitials(author) {
+    const parts = author.trim().split(/\s+/).filter(Boolean);
+    if (!parts.length) return 'AW';
+    return parts.slice(0, 2).map((part)=>Array.from(part)[0] ?? '').join('').toUpperCase();
+}
+async function tableToDocx(element, docx, noteContext) {
+    const rows = [];
+    let inferLeadingHeader = true;
+    for (const row of Array.from(element.rows)){
+        const cells = [];
+        for (const cell of Array.from(row.cells)){
+            const children = [];
+            const blocks = Array.from(cell.children);
+            if (blocks.length) {
+                for (const block of blocks)for (const child of (await blockToFileChildren(block, docx, noteContext)))if (child instanceof docx.Paragraph || child instanceof docx.Table) children.push(child);
+            } else children.push(new docx.Paragraph({
+                children: await inlineRuns(cell, docx, noteContext),
+                ...paragraphDirectionOptions(cell)
+            }));
+            cells.push(new docx.TableCell({
+                children: children.length ? children : [
+                    new docx.Paragraph('')
+                ],
+                columnSpan: cell.colSpan > 1 ? cell.colSpan : void 0,
+                rowSpan: cell.rowSpan > 1 ? cell.rowSpan : void 0,
+                ...documentTableCellDocxOptions(cell, docx),
+                ...documentTableCellSizingDocxOptions(cell, docx),
+                margins: {
+                    top: 80,
+                    right: 100,
+                    bottom: 80,
+                    left: 100
+                }
+            }));
+        }
+        const explicitHeader = dataBoolean(row.dataset.officeRepeatHeader);
+        const inferredHeader = inferLeadingHeader && row.cells.length > 0 && Array.from(row.cells).every((cell)=>'th' === cell.tagName.toLowerCase());
+        const tableHeader = explicitHeader ?? inferredHeader;
+        if (!tableHeader) inferLeadingHeader = false;
+        rows.push(new docx.TableRow({
+            children: cells,
+            cantSplit: dataBoolean(row.dataset.officeCantSplit),
+            tableHeader: tableHeader ? true : void 0,
+            ...documentTableRowSizingDocxOptions(row, docx)
+        }));
+    }
+    return new docx.Table({
+        rows,
+        ...documentTableSizingDocxOptions(element, docx)
+    });
+}
+async function createNoteRecords(notes, kind, docx, noteContext) {
+    const records = {};
+    for (const note of notes)if (note.kind === kind) records[String(note.number)] = {
+        children: await noteParagraphs(note.html, docx, noteContext)
+    };
+    return records;
+}
+async function noteParagraphs(html, docx, noteContext) {
+    const document = new DOMParser().parseFromString(html, 'text/html');
+    const paragraphs = [];
+    for (const child of Array.from(document.body.children)){
+        const element = child;
+        const tag = element.tagName.toLowerCase();
+        if ('ul' === tag || 'ol' === tag) {
+            paragraphs.push(...await listToDocxParagraphs(element, docx, noteContext));
+            continue;
+        }
+        if ('table' === tag) {
+            for (const row of Array.from(element.rows))paragraphs.push(new docx.Paragraph({
+                text: Array.from(row.cells).map((cell)=>cell.textContent?.trim() ?? '').join(' · '),
+                ...paragraphDirectionOptions(row)
+            }));
+            continue;
+        }
+        paragraphs.push(new docx.Paragraph({
+            children: await inlineRuns(element, docx, noteContext),
+            ...paragraphDirectionOptions(element)
+        }));
+    }
+    return paragraphs.length ? paragraphs : [
+        new docx.Paragraph('')
+    ];
+}
+export { createDocxBlob };