@a3s-lab/office 0.31.0 → 0.32.0

package/dist/4166.js

@@ -0,0 +1,3848 @@
+import jszip from "jszip";
+import { normalizeWorkSpreadsheetCombinationSeriesType, workSpreadsheetChartSupportsGrouping, normalizeWorkSpreadsheetChartColor, readXlsxDrawingAnchor, spreadsheetCellAddress, formatSpreadsheetCellRanges, normalizeWorkSpreadsheetChartSmoothLines, spreadsheetFormulaRangeForCell, sparseArrayEntries, spreadsheetPivotFilterValueKey, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetBubbleSizeRepresents, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartGapWidth, workSpreadsheetChartSupportsTrendlines, normalizeWorkSpreadsheetChartGrouping, workSpreadsheetChartSupportsBarSpacing, workSpreadsheetChartSupportsSmoothLines, workSpreadsheetChartGroupingIsStacked, xlsxTwoCellAnchorMarkers, xlsxDrawingAnchorToBounds, workSpreadsheetChartSupportsErrorBars, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetScatterStyle, workSpreadsheetChartAxisDefaultLabelPosition, spreadsheetPivotValidation, resolveSpreadsheetChart, workSpreadsheetChartAxisIsCategoryAxis, parseSpreadsheetCellRanges, spreadsheetPivotFields, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetChartOverlap, editableSpreadsheetFormula, spreadsheetFormulaRangeConflict, spreadsheetFormulaForXlsx, workSpreadsheetChartUsesNumericXAxis, normalizeWorkSpreadsheetChartLegendPosition, workSpreadsheetChartSupportsAxes, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, effectiveSpreadsheetCalculationSettings, normalizeWorkSpreadsheetTrendline, normalizeWorkSpreadsheetRadarStyle, normalizeWorkSpreadsheetDataLabels } from "./8715.js";
+import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage as work_ooxml_package_OoxmlPackage, parseXml, firstDescendant, xmlNamespacePrefix, descendants, directChild, xmlContainsAnyElement, attribute, createOfficeId as createWorkId } from "./4121.js";
+import { DEFAULT_PROTECTION_HINT, editableRangeRequiresCredentials, normalizeSpreadsheetPaperSize, normalizeSheetProtectionAuthority, xlsxWorksheetCellEntries } from "./9333.js";
+async function readXlsxFormulaFeaturesFromPackage(archive, worksheetScans) {
+    if (!archive.has('xl/workbook.xml')) return {
+        calculation: effectiveSpreadsheetCalculationSettings(void 0),
+        sheets: new Map(),
+        unsupportedCalculationAttributes: []
+    };
+    const workbook = await archive.xml('xl/workbook.xml');
+    const worksheetParts = await readWorksheetParts(archive, workbook);
+    const dynamicMetadata = await readDynamicArrayMetadata(archive);
+    const sheets = new Map();
+    for (const [sheetName, partPath] of worksheetParts){
+        if (!archive.has(partPath)) continue;
+        const scan = worksheetScans?.[partPath];
+        if (scan && !scan.hasFormulaFeatures) {
+            sheets.set(sheetName, emptyXlsxFormulaSheetFeatures());
+            continue;
+        }
+        const source = await archive.text(partPath);
+        if (!scan && !xmlContainsAnyElement(source, [
+            'f'
+        ])) {
+            sheets.set(sheetName, emptyXlsxFormulaSheetFeatures());
+            continue;
+        }
+        sheets.set(sheetName, readWorksheetFormulaFeatures(parseXml(source, partPath), dynamicMetadata));
+    }
+    return {
+        calculation: readCalculationSettings(workbook),
+        sheets,
+        unsupportedCalculationAttributes: readUnsupportedCalculationAttributes(workbook)
+    };
+}
+function emptyXlsxFormulaSheetFeatures() {
+    return {
+        formulas: [],
+        ranges: [],
+        sourceFormulas: {},
+        sharedFormulaGroups: 0,
+        sharedFormulaCells: 0,
+        unsupportedFormulaAttributes: []
+    };
+}
+function createSpreadsheetFormulaMetadata(worksheet, features) {
+    const sourceFormulas = {};
+    const rangeByReference = new Map((features?.ranges ?? []).map((range)=>[
+            range.reference.toUpperCase().replaceAll('$', ''),
+            range
+        ]));
+    for (const { address, cell } of xlsxWorksheetCellEntries(worksheet)){
+        const formulaCell = cell;
+        if (formulaCell.f) {
+            const source = features?.sourceFormulas[address.toUpperCase()] ?? formulaCell.f;
+            if (editableSpreadsheetFormula(source) !== source) sourceFormulas[address.toUpperCase()] = source;
+        }
+        if (!formulaCell.f || !formulaCell.F) continue;
+        const reference = formulaCell.F.toUpperCase().replaceAll('$', '');
+        const existing = rangeByReference.get(reference);
+        if (existing) {
+            if (formulaCell.D && 'array' === existing.type) rangeByReference.set(reference, {
+                ...existing,
+                type: 'dynamic-array'
+            });
+            continue;
+        }
+        rangeByReference.set(reference, {
+            type: formulaCell.D ? 'dynamic-array' : 'array',
+            anchor: address.toUpperCase(),
+            reference: formulaCell.F,
+            formula: features?.sourceFormulas[address.toUpperCase()] ?? formulaCell.f
+        });
+    }
+    const ranges = Array.from(rangeByReference.values());
+    const metadata = {
+        ranges: ranges.length ? ranges : void 0,
+        sourceFormulas: Object.keys(sourceFormulas).length ? sourceFormulas : void 0,
+        normalizedSharedFormulaGroups: features?.sharedFormulaGroups || void 0,
+        normalizedSharedFormulaCells: features?.sharedFormulaCells || void 0
+    };
+    return Object.values(metadata).some((value)=>void 0 !== value) ? metadata : void 0;
+}
+function createXlsxFormulaCell(cell, row, column, sheet) {
+    const address = spreadsheetCellAddress(row, column);
+    const range = spreadsheetFormulaRangeForCell(sheet, row, column);
+    const sourceFormula = sheet.formulaMetadata?.sourceFormulas?.[address] ?? range?.formula;
+    const result = {
+        f: spreadsheetFormulaForXlsx(cell.f ?? '', sourceFormula),
+        v: cell.ct?.t === 'e' ? xlsxErrorValue(cell.v, cell.m) : cell.v
+    };
+    if (cell.ct?.t) result.t = cell.ct.t;
+    if (range && 'data-table' !== range.type && !spreadsheetFormulaRangeConflict(sheet, range)) {
+        result.F = range.reference;
+        if ('dynamic-array' === range.type) result.D = true;
+    }
+    return result;
+}
+function createXlsxErrorCell(cell) {
+    return {
+        t: 'e',
+        v: xlsxErrorValue(cell.v, cell.m)
+    };
+}
+async function patchXlsxFormulaFeatures(buffer, content) {
+    const archive = await work_ooxml_package_OoxmlPackage.load(buffer);
+    const zip = await jszip.loadAsync(buffer);
+    if (archive.has('xl/workbook.xml')) {
+        const entry = zip.file('xl/workbook.xml');
+        if (entry) {
+            const workbook = parseXml(await entry.async('text'), 'xl/workbook.xml');
+            writeCalculationSettings(workbook, content.calculation);
+            zip.file('xl/workbook.xml', new XMLSerializer().serializeToString(workbook));
+        }
+    }
+    const dataTables = content.sheets.flatMap((sheet)=>(sheet.formulaMetadata?.ranges ?? []).flatMap((range)=>'data-table' !== range.type || spreadsheetFormulaRangeConflict(sheet, range) ? [] : [
+                {
+                    sheet,
+                    range
+                }
+            ]));
+    if (!dataTables.length || !archive.has('xl/workbook.xml')) return zip.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+    const workbook = await archive.xml('xl/workbook.xml');
+    const worksheetParts = await readWorksheetParts(archive, workbook);
+    for (const sheet of content.sheets){
+        const ranges = dataTables.filter((item)=>item.sheet === sheet).map((item)=>item.range);
+        if (!ranges.length) continue;
+        const partPath = worksheetParts.get(sheet.name.slice(0, 31) || '工作表');
+        const entry = partPath ? zip.file(partPath) : null;
+        if (!partPath || !entry) continue;
+        const document = parseXml(await entry.async('text'), partPath);
+        for (const range of ranges)writeDataTableFormula(document, range);
+        zip.file(partPath, new XMLSerializer().serializeToString(document));
+    }
+    return zip.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function readWorksheetFormulaFeatures(document, dynamicMetadataIndexes) {
+    const formulas = [];
+    const ranges = [];
+    const sourceFormulas = {};
+    const sharedGroups = new Set();
+    const unsupportedFormulaAttributes = new Set();
+    let sharedFormulaCells = 0;
+    for (const cell of descendants(document, 'c')){
+        const formula = directChild(cell, 'f');
+        if (!formula) continue;
+        const address = (attribute(cell, 'r') ?? '').toUpperCase();
+        if (!address) continue;
+        const type = attribute(formula, 't') ?? 'normal';
+        for (const name of unsupportedFormulaAttributesForElement(formula, type))unsupportedFormulaAttributes.add(name);
+        const source = formula.textContent ?? '';
+        if (source) sourceFormulas[address] = source;
+        const cachedError = 'e' === attribute(cell, 't') ? directChild(cell, 'v')?.textContent ?? '' : void 0;
+        formulas.push({
+            address,
+            formula: source,
+            type,
+            cachedError
+        });
+        if ('shared' === type) {
+            sharedFormulaCells += 1;
+            sharedGroups.add(attribute(formula, 'si') ?? `cell:${address}`);
+            continue;
+        }
+        const reference = attribute(formula, 'ref');
+        if ('array' === type && reference) {
+            const metadataIndex = positiveInteger(attribute(cell, 'cm'));
+            ranges.push({
+                type: metadataIndex && dynamicMetadataIndexes.has(metadataIndex) ? 'dynamic-array' : 'array',
+                anchor: address,
+                reference,
+                formula: source || void 0
+            });
+        } else if ('dataTable' === type) ranges.push({
+            type: 'data-table',
+            anchor: address,
+            reference: reference || address,
+            formula: source || void 0,
+            dataTable: readDataTableOptions(formula)
+        });
+    }
+    return {
+        formulas,
+        ranges,
+        sourceFormulas,
+        sharedFormulaGroups: sharedGroups.size,
+        sharedFormulaCells,
+        unsupportedFormulaAttributes: Array.from(unsupportedFormulaAttributes).sort()
+    };
+}
+function readCalculationSettings(workbook) {
+    const calculation = directChild(workbook.documentElement, 'calcPr');
+    return effectiveSpreadsheetCalculationSettings({
+        mode: calculationMode(attribute(calculation ?? workbook.documentElement, 'calcMode')),
+        fullCalculationOnLoad: booleanAttribute(calculation, 'fullCalcOnLoad', false),
+        forceFullCalculation: booleanAttribute(calculation, 'forceFullCalc', false),
+        iterativeCalculation: booleanAttribute(calculation, 'iterate', false),
+        maximumIterations: numericAttribute(calculation, 'iterateCount', 100),
+        maximumChange: numericAttribute(calculation, 'iterateDelta', 0.001),
+        fullPrecision: booleanAttribute(calculation, 'fullPrecision', true)
+    });
+}
+function readUnsupportedCalculationAttributes(workbook) {
+    const calculation = directChild(workbook.documentElement, 'calcPr');
+    if (!calculation) return [];
+    const supported = new Set([
+        'calcId',
+        'calcMode',
+        'forceFullCalc',
+        'fullCalcOnLoad',
+        'fullPrecision',
+        'iterate',
+        'iterateCount',
+        'iterateDelta'
+    ]);
+    return Array.from(calculation.attributes).map((item)=>item.localName).filter((name)=>!supported.has(name)).sort();
+}
+function writeCalculationSettings(workbook, source) {
+    const settings = effectiveSpreadsheetCalculationSettings(source);
+    const root = workbook.documentElement;
+    let calculation = directChild(root, 'calcPr');
+    if (!calculation) {
+        calculation = workbook.createElementNS(root.namespaceURI, 'calcPr');
+        root.insertBefore(calculation, directChild(root, 'extLst') ?? null);
+    }
+    calculation.setAttribute('calcMode', xlsxCalculationMode(settings.mode));
+    calculation.setAttribute('fullCalcOnLoad', booleanValue(settings.fullCalculationOnLoad));
+    calculation.setAttribute('forceFullCalc', booleanValue(settings.forceFullCalculation));
+    calculation.setAttribute('iterate', booleanValue(settings.iterativeCalculation));
+    calculation.setAttribute('iterateCount', String(settings.maximumIterations));
+    calculation.setAttribute('iterateDelta', String(settings.maximumChange));
+    calculation.setAttribute('fullPrecision', booleanValue(settings.fullPrecision));
+}
+async function readWorksheetParts(archive, workbook) {
+    const relationships = await archive.relationships('xl/workbook.xml');
+    const parts = new Map();
+    for (const sheet of firstDescendant(workbook, 'sheets')?.children ?? []){
+        if (!(sheet instanceof Element) || 'sheet' !== sheet.localName) continue;
+        const name = attribute(sheet, 'name');
+        const relationship = relationships.get(attribute(sheet, 'r:id') ?? '');
+        if (name && relationship?.type.endsWith('/worksheet')) parts.set(name, relationship.target);
+    }
+    return parts;
+}
+async function readDynamicArrayMetadata(archive) {
+    if (!archive.has('xl/metadata.xml')) return new Set();
+    const metadata = await archive.xml('xl/metadata.xml');
+    const metadataTypes = directChildren(firstDescendant(metadata, 'metadataTypes') ?? metadata.documentElement);
+    const dynamicTypeIndexes = new Set(metadataTypes.flatMap((item, index)=>'metadataType' === item.localName && attribute(item, 'name')?.toUpperCase() === 'XLDAPR' ? [
+            index + 1
+        ] : []));
+    if (!dynamicTypeIndexes.size) return new Set();
+    const cellMetadata = firstDescendant(metadata, 'cellMetadata');
+    if (!cellMetadata) return new Set();
+    return new Set(directChildren(cellMetadata, 'bk').flatMap((block, index)=>directChildren(block, 'rc').some((record)=>dynamicTypeIndexes.has(positiveInteger(attribute(record, 't')) ?? -1)) ? [
+            index + 1
+        ] : []));
+}
+function readDataTableOptions(formula) {
+    const options = {
+        input1Reference: attribute(formula, 'r1') ?? void 0,
+        input2Reference: attribute(formula, 'r2') ?? void 0,
+        twoDimensional: optionalBooleanAttribute(formula, 'dt2D'),
+        rowOriented: optionalBooleanAttribute(formula, 'dtr'),
+        input1Deleted: optionalBooleanAttribute(formula, 'del1'),
+        input2Deleted: optionalBooleanAttribute(formula, 'del2'),
+        calculateOnLoad: optionalBooleanAttribute(formula, 'ca')
+    };
+    return Object.values(options).some((value)=>void 0 !== value) ? options : void 0;
+}
+function unsupportedFormulaAttributesForElement(formula, type) {
+    const common = [
+        't'
+    ];
+    const supported = 'shared' === type ? new Set([
+        ...common,
+        'ref',
+        'si'
+    ]) : 'array' === type ? new Set([
+        ...common,
+        'ref'
+    ]) : 'dataTable' === type ? new Set([
+        ...common,
+        'ca',
+        'del1',
+        'del2',
+        'dt2D',
+        'dtr',
+        'r1',
+        'r2',
+        'ref'
+    ]) : new Set(common);
+    return Array.from(formula.attributes).map((item)=>item.localName).filter((name)=>!supported.has(name));
+}
+function writeDataTableFormula(document, range) {
+    const anchor = range.anchor.toUpperCase().replaceAll('$', '');
+    const cell = descendants(document, 'c').find((candidate)=>(attribute(candidate, 'r') ?? '').toUpperCase().replaceAll('$', '') === anchor);
+    if (!cell) return;
+    let formula = directChild(cell, 'f');
+    if (!formula) {
+        formula = document.createElementNS(document.documentElement.namespaceURI, 'f');
+        cell.insertBefore(formula, directChild(cell, 'v') ?? cell.firstChild);
+    }
+    for (const item of Array.from(formula.attributes))formula.removeAttribute(item.name);
+    formula.setAttribute('t', 'dataTable');
+    formula.setAttribute('ref', range.reference);
+    formula.textContent = range.formula ?? '';
+    const options = range.dataTable;
+    if (!options) return;
+    setOptionalAttribute(formula, 'r1', options.input1Reference);
+    setOptionalAttribute(formula, 'r2', options.input2Reference);
+    setOptionalBooleanAttribute(formula, 'dt2D', options.twoDimensional);
+    setOptionalBooleanAttribute(formula, 'dtr', options.rowOriented);
+    setOptionalBooleanAttribute(formula, 'del1', options.input1Deleted);
+    setOptionalBooleanAttribute(formula, 'del2', options.input2Deleted);
+    setOptionalBooleanAttribute(formula, 'ca', options.calculateOnLoad);
+}
+function calculationMode(value) {
+    if ('manual' === value) return 'manual';
+    if ('autoNoTable' === value) return 'automatic-except-data-tables';
+    return 'automatic';
+}
+function xlsxCalculationMode(mode) {
+    if ('manual' === mode) return 'manual';
+    if ('automatic-except-data-tables' === mode) return 'autoNoTable';
+    return 'auto';
+}
+function booleanAttribute(element, name, fallback) {
+    const value = element ? attribute(element, name)?.toLowerCase() : null;
+    if (null == value) return fallback;
+    return '1' === value || 'true' === value;
+}
+function optionalBooleanAttribute(element, name) {
+    return null === attribute(element, name) ? void 0 : booleanAttribute(element, name, false);
+}
+function numericAttribute(element, name, fallback) {
+    const value = Number(element ? attribute(element, name) : null);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function positiveInteger(value) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function booleanValue(value) {
+    return value ? '1' : '0';
+}
+function setOptionalAttribute(element, name, value) {
+    if (void 0 !== value) element.setAttribute(name, value);
+}
+function setOptionalBooleanAttribute(element, name, value) {
+    if (void 0 !== value) element.setAttribute(name, booleanValue(value));
+}
+function xlsxErrorValue(value, formatted) {
+    if ('number' == typeof value) return value;
+    const codes = {
+        '#NULL!': 0,
+        '#DIV/0!': 7,
+        '#VALUE!': 15,
+        '#REF!': 23,
+        '#NAME?': 29,
+        '#NUM!': 36,
+        '#N/A': 42,
+        '#GETTING_DATA': 43
+    };
+    return codes[String(formatted ?? value ?? '').toUpperCase()] ?? value;
+}
+function cachedText(parent) {
+    const directValue = directChild(parent, 'v')?.textContent?.trim();
+    return directValue || cachedValues(parent)[0] || '';
+}
+function richText(parent) {
+    return descendants(parent, 't').map((node)=>node.textContent ?? '').join('');
+}
+function cachedValues(parent) {
+    const cache = firstDescendant(parent, 'strCache') ?? firstDescendant(parent, 'numCache') ?? firstDescendant(parent, 'strLit') ?? firstDescendant(parent, 'numLit');
+    if (!cache) return [];
+    const indexed = descendants(cache, 'pt').map((point, order)=>({
+            index: finiteNumber(attribute(point, 'idx'), order),
+            value: directChild(point, 'v')?.textContent ?? ''
+        })).sort((left, right)=>left.index - right.index);
+    if (!indexed.length) return [];
+    const values = Array(indexed.at(-1).index + 1).fill('');
+    for (const point of indexed)values[point.index] = point.value;
+    return values;
+}
+function formulaReference(parent) {
+    return firstDescendant(parent, 'f')?.textContent?.trim().replace(/^=/, '') || void 0;
+}
+function stringCacheXml(values) {
+    return [
+        '<c:strCache>',
+        `<c:ptCount val="${values.length}"/>`,
+        ...values.map((value, index)=>`<c:pt idx="${index}"><c:v>${escapeXml(String(value))}</c:v></c:pt>`),
+        '</c:strCache>'
+    ].join('');
+}
+function numberCacheXml(values) {
+    return [
+        '<c:numCache><c:formatCode>General</c:formatCode>',
+        `<c:ptCount val="${values.length}"/>`,
+        ...values.map((value, index)=>`<c:pt idx="${index}"><c:v>${finiteNumber(value)}</c:v></c:pt>`),
+        '</c:numCache>'
+    ].join('');
+}
+function stringLiteralXml(values) {
+    return [
+        '<c:strLit>',
+        `<c:ptCount val="${values.length}"/>`,
+        ...values.map((value, index)=>`<c:pt idx="${index}"><c:v>${escapeXml(String(value))}</c:v></c:pt>`),
+        '</c:strLit>'
+    ].join('');
+}
+function numberLiteralXml(values) {
+    return [
+        '<c:numLit><c:formatCode>General</c:formatCode>',
+        `<c:ptCount val="${values.length}"/>`,
+        ...values.map((value, index)=>`<c:pt idx="${index}"><c:v>${finiteNumber(value)}</c:v></c:pt>`),
+        '</c:numLit>'
+    ].join('');
+}
+function finiteNumber(value, fallback = 0) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : fallback;
+}
+function escapeXml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+}
+function parseXlsxChartAxes(document, chartType, hasSecondaryAxes, preserveVisibleDefaultGridlines = false) {
+    if (!workSpreadsheetChartSupportsAxes(chartType)) return;
+    const plotArea = firstDescendant(document, 'plotArea');
+    if (!plotArea) return;
+    const axes = {};
+    for (const axis of directChildren(plotArea).filter((node)=>'catAx' === node.localName || 'valAx' === node.localName || 'dateAx' === node.localName)){
+        const position = attribute(directChild(axis, 'axPos') ?? axis, 'val');
+        if ('b' !== position && 'l' !== position && 't' !== position && 'r' !== position) continue;
+        const key = 'b' === position ? 'bottom' : 'l' === position ? 'left' : 't' === position ? 'top' : 'right';
+        const title = directChild(axis, 'title');
+        const text = title ? cachedText(title) || richText(title) || void 0 : void 0;
+        const titleReference = title ? formulaReference(title) : void 0;
+        const displaySettings = parseXlsxAxisDisplaySettings(axis, chartType, key);
+        const valueSettings = 'valAx' === axis.localName ? parseXlsxValueAxisSettings(axis, chartType, key, preserveVisibleDefaultGridlines) : void 0;
+        if (text || titleReference || displaySettings || valueSettings) axes[key] = {
+            ...text ? {
+                title: text
+            } : {},
+            ...titleReference ? {
+                titleReference
+            } : {},
+            ...displaySettings,
+            ...valueSettings
+        };
+    }
+    return normalizeWorkSpreadsheetChartAxes(axes, chartType, hasSecondaryAxes);
+}
+function parseXlsxAxisDisplaySettings(axis, chartType, position) {
+    const orientation = attribute(directChild(directChild(axis, 'scaling') ?? axis, 'orientation') ?? axis, 'val');
+    const rawLabelPosition = attribute(directChild(axis, 'tickLblPos') ?? axis, 'val');
+    const labelPosition = 'nextTo' === rawLabelPosition || 'high' === rawLabelPosition || 'low' === rawLabelPosition || 'none' === rawLabelPosition ? rawLabelPosition : void 0;
+    const rawTickMark = attribute(directChild(axis, 'majorTickMark') ?? axis, 'val');
+    const majorTickMark = 'in' === rawTickMark ? 'inside' : 'out' === rawTickMark ? 'outside' : 'cross' === rawTickMark ? 'cross' : 'none' === rawTickMark ? 'none' : void 0;
+    const rawInterval = workSpreadsheetChartAxisIsCategoryAxis(chartType, position) ? finiteAttributeValue(directChild(axis, 'tickLblSkip')) : void 0;
+    const labelInterval = Number.isInteger(rawInterval) && Number(rawInterval) >= 1 && Number(rawInterval) <= 31999 ? Number(rawInterval) : void 0;
+    const defaultLabelPosition = workSpreadsheetChartAxisDefaultLabelPosition(chartType, position);
+    const settings = {
+        ...'maxMin' === orientation ? {
+            reverseOrder: true
+        } : {},
+        ...labelPosition && labelPosition !== defaultLabelPosition ? {
+            labelPosition
+        } : {},
+        ...majorTickMark && 'none' !== majorTickMark ? {
+            majorTickMark
+        } : {},
+        ...void 0 !== labelInterval ? {
+            labelInterval
+        } : {}
+    };
+    return Object.keys(settings).length ? settings : void 0;
+}
+function chartTextTitleXml(title, reference) {
+    const text = reference?.trim() ? `<c:strRef><c:f>${escapeXml(reference.replace(/^=/, ''))}</c:f>${stringCacheXml([
+        title
+    ])}</c:strRef>` : [
+        '<c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:rPr lang="zh-CN" sz="1400" b="0"/>',
+        `<a:t>${escapeXml(title)}</a:t></a:r><a:endParaRPr lang="zh-CN"/></a:p></c:rich>`
+    ].join('');
+    return `<c:title><c:tx>${text}</c:tx><c:layout/><c:overlay val="0"/></c:title>`;
+}
+function chartAxisScalingXml(axis, includeBounds) {
+    return [
+        `<c:scaling><c:orientation val="${axis?.reverseOrder === true ? 'maxMin' : 'minMax'}"/>`,
+        includeBounds && Number.isFinite(axis?.maximum) ? `<c:max val="${Number(axis?.maximum)}"/>` : '',
+        includeBounds && Number.isFinite(axis?.minimum) ? `<c:min val="${Number(axis?.minimum)}"/>` : '',
+        '</c:scaling>'
+    ].join('');
+}
+function chartAxisTickLabelPositionXml(axis, chartType, position) {
+    const value = axis?.labelPosition ?? workSpreadsheetChartAxisDefaultLabelPosition(chartType, position);
+    return `<c:tickLblPos val="${value}"/>`;
+}
+function chartAxisMajorTickMarkXml(axis) {
+    const value = axis?.majorTickMark;
+    if (!value || 'none' === value) return '';
+    const nativeValue = 'inside' === value ? 'in' : 'outside' === value ? 'out' : 'cross';
+    return `<c:majorTickMark val="${nativeValue}"/>`;
+}
+function chartCategoryAxisLabelIntervalXml(axis) {
+    return Number.isInteger(axis?.labelInterval) && Number(axis?.labelInterval) >= 1 ? `<c:tickLblSkip val="${Number(axis?.labelInterval)}"/>` : '';
+}
+function chartAxesXml(chart, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId) {
+    if (workSpreadsheetChartUsesNumericXAxis(chart.type)) return xyChartAxesXml(chart, categoryAxisId, valueAxisId);
+    if ('combination' === chart.type) return combinationChartAxesXml(chart, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId);
+    const horizontalBars = 'bar' === chart.type;
+    const categoryAxis = horizontalBars ? chart.axes?.left : chart.axes?.bottom;
+    const categoryAxisPosition = horizontalBars ? 'left' : 'bottom';
+    const categoryAxisTitle = chartAxisTitleXml(categoryAxis);
+    const valueAxisPosition = horizontalBars ? 'bottom' : 'left';
+    const valueAxis = horizontalBars ? chart.axes?.bottom : chart.axes?.left;
+    return [
+        '<c:catAx>',
+        `<c:axId val="${categoryAxisId}"/>`,
+        `${chartAxisScalingXml(categoryAxis, false)}<c:delete val="0"/>`,
+        `<c:axPos val="${horizontalBars ? 'l' : 'b'}"/>`,
+        categoryAxisTitle,
+        chartAxisMajorTickMarkXml(categoryAxis),
+        chartAxisTickLabelPositionXml(categoryAxis, chart.type, categoryAxisPosition),
+        `<c:crossAx val="${valueAxisId}"/><c:crosses val="autoZero"/>`,
+        `<c:auto val="1"/><c:lblAlgn val="ctr"/><c:lblOffset val="100"/>${chartCategoryAxisLabelIntervalXml(categoryAxis)}`,
+        '</c:catAx>',
+        '<c:valAx>',
+        `<c:axId val="${valueAxisId}"/>`,
+        `${chartAxisScalingXml(valueAxis, true)}<c:delete val="0"/>`,
+        `<c:axPos val="${horizontalBars ? 'b' : 'l'}"/>`,
+        chartValueAxisGridlinesXml(valueAxis, chart.type, valueAxisPosition),
+        chartAxisTitleXml(valueAxis),
+        `${chartValueAxisNumberFormatXml(valueAxis)}${chartAxisMajorTickMarkXml(valueAxis)}${chartAxisTickLabelPositionXml(valueAxis, chart.type, valueAxisPosition)}`,
+        `<c:crossAx val="${categoryAxisId}"/><c:crosses val="autoZero"/><c:crossBetween val="between"/>`,
+        chartValueAxisMajorUnitXml(valueAxis),
+        '</c:valAx>'
+    ].join('');
+}
+function parseXlsxValueAxisSettings(axis, chartType, position, preserveVisibleDefaultGridlines) {
+    const scaling = directChild(axis, 'scaling');
+    const minimum = finiteAttributeValue(scaling ? directChild(scaling, 'min') : null);
+    const maximum = finiteAttributeValue(scaling ? directChild(scaling, 'max') : null);
+    const majorUnit = finiteAttributeValue(directChild(axis, 'majorUnit'));
+    const showMajorGridlines = 1 === directChildren(axis, 'majorGridlines').length;
+    const defaultGridlines = workSpreadsheetChartAxisShowsMajorGridlinesByDefault(chartType, position);
+    const numberFormatNode = directChild(axis, 'numFmt');
+    const numberFormat = attribute(numberFormatNode ?? axis, 'formatCode')?.trim();
+    const numberFormatSourceLinked = numberFormatNode ? readBooleanValue(attribute(numberFormatNode, 'sourceLinked')) : void 0;
+    const defaultNumberFormat = (!numberFormat || 'General' === numberFormat) && false !== numberFormatSourceLinked;
+    const settings = {
+        ...void 0 !== minimum ? {
+            minimum
+        } : {},
+        ...void 0 !== maximum ? {
+            maximum
+        } : {},
+        ...void 0 !== majorUnit && majorUnit > 0 ? {
+            majorUnit
+        } : {},
+        ...showMajorGridlines !== defaultGridlines || showMajorGridlines && preserveVisibleDefaultGridlines ? {
+            showMajorGridlines
+        } : {},
+        ...!defaultNumberFormat && numberFormat ? {
+            numberFormat
+        } : {},
+        ...!defaultNumberFormat && void 0 !== numberFormatSourceLinked ? {
+            numberFormatSourceLinked
+        } : {}
+    };
+    return Object.keys(settings).length ? settings : void 0;
+}
+function chartAxisTitleXml(axis) {
+    if (!axis) return '';
+    const title = axis.title?.trim();
+    if (!title && !axis.titleReference?.trim()) return '';
+    return chartTextTitleXml(title ?? '', axis.titleReference);
+}
+function chartValueAxisGridlinesXml(axis, chartType, position) {
+    const visible = axis?.showMajorGridlines ?? workSpreadsheetChartAxisShowsMajorGridlinesByDefault(chartType, position);
+    return visible ? '<c:majorGridlines/>' : '';
+}
+function chartValueAxisNumberFormatXml(axis) {
+    const formatCode = axis?.numberFormat?.trim() || 'General';
+    const sourceLinked = axis?.numberFormat ? true === axis.numberFormatSourceLinked : axis?.numberFormatSourceLinked !== false;
+    return `<c:numFmt formatCode="${escapeXml(formatCode)}" sourceLinked="${sourceLinked ? 1 : 0}"/>`;
+}
+function chartValueAxisMajorUnitXml(axis) {
+    return Number.isFinite(axis?.majorUnit) && Number(axis?.majorUnit) > 0 ? `<c:majorUnit val="${Number(axis?.majorUnit)}"/>` : '';
+}
+function combinationChartAxesXml(chart, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId) {
+    const primaryCategoryAxis = chart.axes?.bottom;
+    const primaryValueAxis = chart.axes?.left;
+    const primary = [
+        '<c:catAx>',
+        `<c:axId val="${categoryAxisId}"/>`,
+        `${chartAxisScalingXml(primaryCategoryAxis, false)}<c:delete val="0"/><c:axPos val="b"/>`,
+        chartAxisTitleXml(primaryCategoryAxis),
+        chartAxisMajorTickMarkXml(primaryCategoryAxis),
+        chartAxisTickLabelPositionXml(primaryCategoryAxis, chart.type, 'bottom'),
+        `<c:crossAx val="${valueAxisId}"/><c:crosses val="autoZero"/>`,
+        `<c:auto val="1"/><c:lblAlgn val="ctr"/><c:lblOffset val="100"/>${chartCategoryAxisLabelIntervalXml(primaryCategoryAxis)}`,
+        '</c:catAx>',
+        '<c:valAx>',
+        `<c:axId val="${valueAxisId}"/>`,
+        `${chartAxisScalingXml(primaryValueAxis, true)}<c:delete val="0"/><c:axPos val="l"/>`,
+        chartValueAxisGridlinesXml(primaryValueAxis, chart.type, 'left'),
+        chartAxisTitleXml(primaryValueAxis),
+        `${chartValueAxisNumberFormatXml(primaryValueAxis)}${chartAxisMajorTickMarkXml(primaryValueAxis)}${chartAxisTickLabelPositionXml(primaryValueAxis, chart.type, 'left')}`,
+        `<c:crossAx val="${categoryAxisId}"/><c:crosses val="autoZero"/><c:crossBetween val="between"/>`,
+        chartValueAxisMajorUnitXml(primaryValueAxis),
+        '</c:valAx>'
+    ].join('');
+    const hasSecondary = chart.series.some((series)=>'secondary' === normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup));
+    if (!hasSecondary) return primary;
+    const secondaryCategoryAxis = chart.axes?.top;
+    const secondaryValueAxis = chart.axes?.right;
+    const secondaryCategoryLabelPosition = secondaryCategoryAxis?.labelPosition ?? workSpreadsheetChartAxisDefaultLabelPosition(chart.type, 'top');
+    const secondary = [
+        '<c:catAx>',
+        `<c:axId val="${secondaryCategoryAxisId}"/>`,
+        `${chartAxisScalingXml(secondaryCategoryAxis, false)}<c:delete val="${'none' === secondaryCategoryLabelPosition ? 1 : 0}"/><c:axPos val="t"/>`,
+        chartAxisTitleXml(secondaryCategoryAxis),
+        chartAxisMajorTickMarkXml(secondaryCategoryAxis),
+        chartAxisTickLabelPositionXml(secondaryCategoryAxis, chart.type, 'top'),
+        `<c:crossAx val="${secondaryValueAxisId}"/><c:crosses val="max"/>`,
+        `<c:auto val="1"/><c:lblAlgn val="ctr"/><c:lblOffset val="100"/>${chartCategoryAxisLabelIntervalXml(secondaryCategoryAxis)}`,
+        '</c:catAx>',
+        '<c:valAx>',
+        `<c:axId val="${secondaryValueAxisId}"/>`,
+        `${chartAxisScalingXml(secondaryValueAxis, true)}<c:delete val="0"/><c:axPos val="r"/>`,
+        chartValueAxisGridlinesXml(secondaryValueAxis, chart.type, 'right'),
+        chartAxisTitleXml(secondaryValueAxis),
+        `${chartValueAxisNumberFormatXml(secondaryValueAxis)}${chartAxisMajorTickMarkXml(secondaryValueAxis)}${chartAxisTickLabelPositionXml(secondaryValueAxis, chart.type, 'right')}`,
+        `<c:crossAx val="${secondaryCategoryAxisId}"/><c:crosses val="max"/><c:crossBetween val="between"/>`,
+        chartValueAxisMajorUnitXml(secondaryValueAxis),
+        '</c:valAx>'
+    ].join('');
+    return `${primary}${secondary}`;
+}
+function xyChartAxesXml(chart, horizontalAxisId, verticalAxisId) {
+    const horizontalAxis = chart.axes?.bottom;
+    const verticalAxis = chart.axes?.left;
+    return [
+        '<c:valAx>',
+        `<c:axId val="${horizontalAxisId}"/>`,
+        `${chartAxisScalingXml(horizontalAxis, true)}<c:delete val="0"/>`,
+        '<c:axPos val="b"/>',
+        chartValueAxisGridlinesXml(horizontalAxis, chart.type, 'bottom'),
+        chartAxisTitleXml(horizontalAxis),
+        `${chartValueAxisNumberFormatXml(horizontalAxis)}${chartAxisMajorTickMarkXml(horizontalAxis)}${chartAxisTickLabelPositionXml(horizontalAxis, chart.type, 'bottom')}`,
+        `<c:crossAx val="${verticalAxisId}"/><c:crosses val="autoZero"/><c:crossBetween val="midCat"/>`,
+        chartValueAxisMajorUnitXml(horizontalAxis),
+        '</c:valAx>',
+        '<c:valAx>',
+        `<c:axId val="${verticalAxisId}"/>`,
+        `${chartAxisScalingXml(verticalAxis, true)}<c:delete val="0"/>`,
+        '<c:axPos val="l"/>',
+        chartValueAxisGridlinesXml(verticalAxis, chart.type, 'left'),
+        chartAxisTitleXml(verticalAxis),
+        `${chartValueAxisNumberFormatXml(verticalAxis)}${chartAxisMajorTickMarkXml(verticalAxis)}${chartAxisTickLabelPositionXml(verticalAxis, chart.type, 'left')}`,
+        `<c:crossAx val="${horizontalAxisId}"/><c:crosses val="autoZero"/><c:crossBetween val="midCat"/>`,
+        chartValueAxisMajorUnitXml(verticalAxis),
+        '</c:valAx>'
+    ].join('');
+}
+function finiteAttributeValue(element) {
+    const source = element ? attribute(element, 'val') : null;
+    const value = source?.trim() ? Number(source) : NaN;
+    return Number.isFinite(value) ? value : void 0;
+}
+function readBooleanValue(value) {
+    return '1' === value || 'true' === value;
+}
+const LEGEND_POSITIONS = new Set([
+    'r',
+    'l',
+    't',
+    'b',
+    'tr'
+]);
+const LEGEND_CHILDREN = new Set([
+    'legendPos',
+    'layout',
+    'overlay'
+]);
+const BAR_GROUPINGS = new Set([
+    'clustered',
+    'standard',
+    'stacked',
+    'percentStacked'
+]);
+const LINE_AREA_GROUPINGS = new Set([
+    'standard',
+    'stacked',
+    'percentStacked'
+]);
+function parseXlsxChartLegend(document) {
+    const legend = firstDescendant(document, 'legend');
+    if (!legend) return {
+        showLegend: false
+    };
+    const position = xlsxLegendPosition(attribute(directChild(legend, 'legendPos') ?? legend, 'val'));
+    const overlayElement = directChild(legend, 'overlay');
+    const overlay = overlayElement ? xlsxBooleanValue(attribute(overlayElement, 'val')) : false;
+    return {
+        showLegend: true,
+        legendPosition: normalizeWorkSpreadsheetChartLegendPosition(position),
+        legendOverlay: normalizeWorkSpreadsheetChartLegendOverlay(overlay)
+    };
+}
+function xlsxChartLegendXml(chart) {
+    if (!chart.showLegend) return '';
+    const position = xlsxLegendPositionValue(normalizeWorkSpreadsheetChartLegendPosition(chart.legendPosition));
+    const overlay = normalizeWorkSpreadsheetChartLegendOverlay(chart.legendOverlay) ? 1 : 0;
+    return `<c:legend><c:legendPos val="${position}"/><c:layout/><c:overlay val="${overlay}"/></c:legend>`;
+}
+function parseXlsxChartPlotLayout(chartNode, chartType) {
+    if (!workSpreadsheetChartSupportsGrouping(chartType)) return {};
+    const grouping = normalizeWorkSpreadsheetChartGrouping(attribute(directChild(chartNode, 'grouping') ?? chartNode, 'val'), chartType);
+    const gapWidth = directChild(chartNode, 'gapWidth');
+    const overlap = directChild(chartNode, 'overlap');
+    return {
+        grouping,
+        ...workSpreadsheetChartSupportsBarSpacing(chartType) ? {
+            gapWidth: normalizeWorkSpreadsheetChartGapWidth(gapWidth ? attribute(gapWidth, 'val') : void 0),
+            overlap: normalizeWorkSpreadsheetChartOverlap(overlap ? attribute(overlap, 'val') : void 0, grouping)
+        } : {},
+        ...workSpreadsheetChartSupportsSmoothLines(chartType) ? {
+            smoothLines: normalizeWorkSpreadsheetChartSmoothLines(consistentLineSmooth(chartNode))
+        } : {}
+    };
+}
+function xlsxChartGroupingValue(chart) {
+    return normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type);
+}
+function xlsxChartGapWidthValue(chart) {
+    return normalizeWorkSpreadsheetChartGapWidth(chart.gapWidth);
+}
+function xlsxChartOverlapValue(chart) {
+    const grouping = xlsxChartGroupingValue(chart);
+    return normalizeWorkSpreadsheetChartOverlap(chart.overlap, grouping);
+}
+function xlsxChartSmoothLinesValue(chart) {
+    return normalizeWorkSpreadsheetChartSmoothLines(chart.smoothLines);
+}
+function xlsxChartNodeUsesStackedGrouping(chartNode) {
+    const grouping = attribute(directChild(chartNode, 'grouping') ?? chartNode, 'val');
+    return 'stacked' === grouping || 'percentStacked' === grouping;
+}
+function isSupportedXlsxChartLegend(document) {
+    const chart = firstDescendant(document, 'chart');
+    if (!chart) return true;
+    const legends = directChildren(chart, 'legend');
+    if (legends.length > 1) return false;
+    const legend = legends[0];
+    if (!legend) return true;
+    const children = directChildren(legend);
+    if (children.some((child)=>!LEGEND_CHILDREN.has(child.localName))) return false;
+    const positions = directChildren(legend, 'legendPos');
+    if (positions.length > 1 || positions[0] && !LEGEND_POSITIONS.has(attribute(positions[0], 'val') ?? '')) return false;
+    const layouts = directChildren(legend, 'layout');
+    if (layouts.length > 1 || layouts.some((layout)=>directChildren(layout).length > 0)) return false;
+    return validOptionalBooleanElement(legend, 'overlay');
+}
+function isSupportedXlsxChartPlotLayout(chart) {
+    const grouping = directChildren(chart, 'grouping');
+    if (grouping.length > 1) return false;
+    if ('barChart' === chart.localName) {
+        if (!grouping.length || !BAR_GROUPINGS.has(attribute(grouping[0], 'val') ?? '')) return false;
+        if (!validOptionalIntegerElement(chart, 'gapWidth', 0, 500)) return false;
+        if (!validOptionalIntegerElement(chart, 'overlap', -100, 100)) return false;
+    } else if ('lineChart' === chart.localName || 'areaChart' === chart.localName) {
+        if (!grouping.length || !LINE_AREA_GROUPINGS.has(attribute(grouping[0], 'val') ?? '')) return false;
+        if (directChildren(chart, 'gapWidth').length || directChildren(chart, 'overlap').length) return false;
+    } else if (grouping.length || directChildren(chart, 'gapWidth').length || directChildren(chart, 'overlap').length) return false;
+    if ('lineChart' === chart.localName) {
+        if (!hasConsistentLineSmooth(chart)) return false;
+    } else if ('scatterChart' !== chart.localName && descendants(chart, 'smooth').some((element)=>xlsxBooleanValue(attribute(element, 'val')))) return false;
+    if ('scatterChart' === chart.localName && ![
+        'marker',
+        'line',
+        'lineMarker',
+        'smooth',
+        'smoothMarker'
+    ].includes(attribute(firstDescendant(chart, 'scatterStyle') ?? chart, 'val') ?? '')) return false;
+    if (descendants(chart, 'bubble3D').some((element)=>xlsxBooleanValue(attribute(element, 'val')))) return false;
+    if (descendants(chart, 'explosion').some((element)=>0 !== Number(attribute(element, 'val')))) return false;
+    return !descendants(chart, 'firstSliceAng').some((element)=>0 !== Number(attribute(element, 'val')));
+}
+function isSupportedXlsxCombinationPlotNode(chart) {
+    if (!isSupportedXlsxChartPlotLayout(chart)) return false;
+    const grouping = attribute(directChild(chart, 'grouping') ?? chart, 'val');
+    if ('lineChart' === chart.localName || 'areaChart' === chart.localName) return 'standard' === grouping && ('lineChart' !== chart.localName || false === consistentLineSmooth(chart));
+    if ('barChart' !== chart.localName || 'clustered' !== grouping) return false;
+    const gapWidth = directChild(chart, 'gapWidth');
+    const overlap = directChild(chart, 'overlap');
+    return 150 === Number(attribute(gapWidth ?? chart, 'val') ?? 150) && 0 === Number(attribute(overlap ?? chart, 'val') ?? 0);
+}
+function xlsxChartGroupingIsStacked(chart) {
+    return workSpreadsheetChartGroupingIsStacked(xlsxChartGroupingValue(chart));
+}
+function xlsxLegendPosition(value) {
+    if ('l' === value) return 'left';
+    if ('t' === value) return 'top';
+    if ('b' === value) return 'bottom';
+    if ('tr' === value) return 'topRight';
+    return 'right';
+}
+function xlsxLegendPositionValue(position) {
+    if ('left' === position) return 'l';
+    if ('top' === position) return 't';
+    if ('bottom' === position) return 'b';
+    if ('topRight' === position) return 'tr';
+    return 'r';
+}
+function hasConsistentLineSmooth(chart) {
+    const chartSmooth = directChildren(chart, 'smooth');
+    if (chartSmooth.length > 1 || !chartSmooth.every(validBooleanElement)) return false;
+    const series = directChildren(chart, 'ser');
+    if (series.some((item)=>directChildren(item, 'smooth').length > 1)) return false;
+    const explicit = [
+        ...chartSmooth,
+        ...series.flatMap((item)=>directChildren(item, 'smooth'))
+    ];
+    if (!explicit.every(validBooleanElement)) return false;
+    if (!explicit.length) return true;
+    const values = explicit.map((element)=>xlsxBooleanValue(attribute(element, 'val')));
+    return values.every((value)=>value === values[0]);
+}
+function consistentLineSmooth(chart) {
+    const explicit = [
+        ...directChildren(chart, 'smooth'),
+        ...directChildren(chart, 'ser').flatMap((series)=>directChildren(series, 'smooth'))
+    ];
+    if (!explicit.length || !hasConsistentLineSmooth(chart)) return false;
+    return xlsxBooleanValue(attribute(explicit[0], 'val'));
+}
+function validOptionalIntegerElement(parent, localName, minimum, maximum) {
+    const elements = directChildren(parent, localName);
+    if (elements.length > 1) return false;
+    if (!elements.length) return true;
+    const value = Number(attribute(elements[0], 'val'));
+    return Number.isInteger(value) && value >= minimum && value <= maximum;
+}
+function validOptionalBooleanElement(parent, localName) {
+    const elements = directChildren(parent, localName);
+    return elements.length <= 1 && elements.every(validBooleanElement);
+}
+function validBooleanElement(element) {
+    const value = attribute(element, 'val');
+    return null === value || '0' === value || '1' === value || 'false' === value || 'true' === value;
+}
+function xlsxBooleanValue(value) {
+    return null === value || '1' === value || 'true' === value;
+}
+const EMUS_PER_POINT = 12700;
+const DASH_VALUES = new Set([
+    'solid',
+    'dash',
+    'dot',
+    'dashDot'
+]);
+const MARKER_VALUES = new Set([
+    'none',
+    'circle',
+    'square',
+    'diamond',
+    'triangle',
+    'plus',
+    'x',
+    'star'
+]);
+const MARKER_CHART_ELEMENTS = new Set([
+    'lineChart',
+    'radarChart',
+    'scatterChart'
+]);
+function parseXlsxChartSeriesStyle(series) {
+    const shape = directChild(series, 'spPr');
+    const base = shape ? parseShapeProperties(shape) : void 0;
+    const markerNode = directChild(series, 'marker');
+    const marker = markerNode ? parseMarkerStyle(markerNode) : void 0;
+    return normalizeWorkSpreadsheetChartSeriesStyle({
+        ...base,
+        ...marker ? {
+            marker
+        } : {}
+    });
+}
+function xlsxChartSeriesShapePropertiesXml(style) {
+    const normalized = normalizeWorkSpreadsheetChartSeriesStyle(style);
+    if (!normalized) return '';
+    const fill = normalized.fillColor ? xlsxSolidFillXml(normalized.fillColor, normalized.fillTransparency) : '';
+    const line = xlsxLineXml(normalized);
+    return fill || line ? `<c:spPr>${fill}${line}</c:spPr>` : '';
+}
+function xlsxChartSeriesMarkerXml(style, defaultVisible, defaultSize = 5) {
+    const marker = normalizeWorkSpreadsheetChartSeriesStyle(style)?.marker;
+    if (!marker) return defaultVisible ? `<c:marker><c:symbol val="circle"/><c:size val="${defaultSize}"/></c:marker>` : '<c:marker><c:symbol val="none"/></c:marker>';
+    const symbol = marker.symbol ?? 'circle';
+    if ('none' === symbol) return '<c:marker><c:symbol val="none"/></c:marker>';
+    const size = marker.size ?? defaultSize;
+    const shape = xlsxMarkerShapePropertiesXml(marker);
+    return `<c:marker><c:symbol val="${symbol}"/><c:size val="${size}"/>${shape}</c:marker>`;
+}
+function isSupportedXlsxChartSeriesFormatting(series, chartLocalName) {
+    const shapeProperties = directChildren(series, 'spPr');
+    if (shapeProperties.length > 1 || shapeProperties.some((shape)=>!isSupportedSeriesShapeProperties(shape))) return false;
+    const markers = directChildren(series, 'marker');
+    if (markers.length > 1) return false;
+    if (!markers.length) return true;
+    if (!MARKER_CHART_ELEMENTS.has(chartLocalName)) return false;
+    return isSupportedMarker(markers[0]);
+}
+function xlsxChartSeriesFormattingShapeProperties(series) {
+    return [
+        ...directChildren(series, 'spPr'),
+        ...directChildren(series, 'marker').flatMap((marker)=>directChildren(marker, 'spPr'))
+    ];
+}
+function parseShapeProperties(shape) {
+    const fill = parseSolidFill(directChild(shape, 'solidFill'));
+    const line = directChild(shape, 'ln');
+    const lineFill = line ? parseSolidFill(directChild(line, 'solidFill')) : void 0;
+    const width = line ? xlsxLineWidth(line) : void 0;
+    const dash = line ? xlsxLineDash(line) : void 0;
+    return normalizeWorkSpreadsheetChartSeriesStyle({
+        ...fill ? {
+            fillColor: fill.color,
+            ...void 0 !== fill.transparency ? {
+                fillTransparency: fill.transparency
+            } : {}
+        } : {},
+        ...lineFill ? {
+            lineColor: lineFill.color
+        } : {},
+        ...void 0 !== width ? {
+            lineWidth: width
+        } : {},
+        ...dash ? {
+            lineDash: dash
+        } : {}
+    });
+}
+function parseMarkerStyle(marker) {
+    const symbol = attribute(directChild(marker, 'symbol') ?? marker, 'val');
+    const sizeSource = attribute(directChild(marker, 'size') ?? marker, 'val');
+    const size = null === sizeSource ? void 0 : Number(sizeSource);
+    const shape = directChild(marker, 'spPr');
+    const fill = shape ? parseSolidFill(directChild(shape, 'solidFill')) : void 0;
+    const line = shape ? directChild(shape, 'ln') : void 0;
+    const lineFill = line ? parseSolidFill(directChild(line, 'solidFill')) : void 0;
+    const parsed = {
+        ...MARKER_VALUES.has(symbol) ? {
+            symbol: symbol
+        } : {},
+        ...Number.isFinite(size) ? {
+            size
+        } : {},
+        ...fill ? {
+            fillColor: fill.color
+        } : {},
+        ...lineFill ? {
+            lineColor: lineFill.color
+        } : {}
+    };
+    return Object.keys(parsed).length ? parsed : void 0;
+}
+function parseSolidFill(fill) {
+    if (!fill) return;
+    const color = directChild(fill, 'srgbClr');
+    const normalized = normalizeWorkSpreadsheetChartColor(attribute(color ?? fill, 'val'));
+    if (!color || !normalized) return;
+    const alphaElement = directChild(color, 'alpha');
+    if (!alphaElement) return {
+        color: normalized
+    };
+    const alphaSource = attribute(alphaElement, 'val');
+    if (null === alphaSource) return {
+        color: normalized
+    };
+    const alpha = Number(alphaSource);
+    if (!Number.isFinite(alpha)) return {
+        color: normalized
+    };
+    return {
+        color: normalized,
+        transparency: Math.round((100 - alpha / 1000) * 100) / 100
+    };
+}
+function xlsxLineWidth(line) {
+    const source = attribute(line, 'w');
+    if (null === source) return;
+    const width = Number(source);
+    return Number.isFinite(width) ? Math.round(width / EMUS_PER_POINT * 100) / 100 : void 0;
+}
+function xlsxLineDash(line) {
+    const value = attribute(directChild(line, 'prstDash') ?? line, 'val');
+    return DASH_VALUES.has(value) ? value : void 0;
+}
+function xlsxSolidFillXml(color, transparency) {
+    const value = color.replace(/^#/, '');
+    if (void 0 === transparency) return `<a:solidFill><a:srgbClr val="${value}"/></a:solidFill>`;
+    return `<a:solidFill><a:srgbClr val="${value}"><a:alpha val="${Math.round((100 - transparency) * 1000)}"/></a:srgbClr></a:solidFill>`;
+}
+function xlsxLineXml(style) {
+    if (!style.lineColor && void 0 === style.lineWidth && !style.lineDash) return '';
+    const width = void 0 === style.lineWidth ? '' : ` w="${Math.round(style.lineWidth * EMUS_PER_POINT)}"`;
+    const fill = style.lineColor ? xlsxSolidFillXml(style.lineColor) : '';
+    const dash = style.lineDash ? `<a:prstDash val="${style.lineDash}"/>` : '';
+    return `<a:ln${width}>${fill}${dash}</a:ln>`;
+}
+function xlsxMarkerShapePropertiesXml(marker) {
+    const fill = marker.fillColor ? xlsxSolidFillXml(marker.fillColor) : '';
+    const line = marker.lineColor ? `<a:ln>${xlsxSolidFillXml(marker.lineColor)}</a:ln>` : '';
+    return fill || line ? `<c:spPr>${fill}${line}</c:spPr>` : '';
+}
+function isSupportedSeriesShapeProperties(shape) {
+    if (!hasOnlyAttributes(shape, [])) return false;
+    const children = directChildren(shape);
+    if (children.some((child)=>'solidFill' !== child.localName && 'ln' !== child.localName)) return false;
+    const fills = directChildren(shape, 'solidFill');
+    const lines = directChildren(shape, 'ln');
+    if (fills.length > 1 || lines.length > 1) return false;
+    if (fills.some((fill)=>!isSupportedSolidFill(fill, true))) return false;
+    return !lines.length || isSupportedSeriesLine(lines[0]);
+}
+function isSupportedSeriesLine(line) {
+    if (!hasOnlyAttributes(line, [
+        'w'
+    ])) return false;
+    const children = directChildren(line);
+    if (children.some((child)=>'solidFill' !== child.localName && 'prstDash' !== child.localName)) return false;
+    const fills = directChildren(line, 'solidFill');
+    const dashes = directChildren(line, 'prstDash');
+    if (fills.length > 1 || dashes.length > 1 || fills.some((fill)=>!isSupportedSolidFill(fill, false))) return false;
+    const widthSource = attribute(line, 'w');
+    if (null !== widthSource) {
+        const width = Number(widthSource);
+        if (!Number.isInteger(width) || width < 0.25 * EMUS_PER_POINT || width > 20 * EMUS_PER_POINT) return false;
+    }
+    return !dashes.length || DASH_VALUES.has(attribute(dashes[0], 'val'));
+}
+function isSupportedMarker(marker) {
+    if (!hasOnlyAttributes(marker, [])) return false;
+    const children = directChildren(marker);
+    if (children.some((child)=>![
+            'symbol',
+            'size',
+            'spPr'
+        ].includes(child.localName))) return false;
+    const symbols = directChildren(marker, 'symbol');
+    const sizes = directChildren(marker, 'size');
+    const shapes = directChildren(marker, 'spPr');
+    if (1 !== symbols.length || sizes.length > 1 || shapes.length > 1) return false;
+    const symbol = attribute(symbols[0], 'val');
+    if (!hasOnlyAttributes(symbols[0], [
+        'val'
+    ])) return false;
+    if (!MARKER_VALUES.has(symbol)) return false;
+    if (sizes.length) {
+        if (!hasOnlyAttributes(sizes[0], [
+            'val'
+        ])) return false;
+        const size = Number(attribute(sizes[0], 'val'));
+        if (!Number.isInteger(size) || size < 2 || size > 72 || 'none' === symbol) return false;
+    }
+    return !shapes.length || isSupportedMarkerShapeProperties(shapes[0]);
+}
+function isSupportedMarkerShapeProperties(shape) {
+    if (!hasOnlyAttributes(shape, [])) return false;
+    const children = directChildren(shape);
+    if (children.some((child)=>'solidFill' !== child.localName && 'ln' !== child.localName)) return false;
+    const fills = directChildren(shape, 'solidFill');
+    const lines = directChildren(shape, 'ln');
+    if (fills.length > 1 || lines.length > 1 || fills.some((fill)=>!isSupportedSolidFill(fill, false))) return false;
+    if (!lines.length) return true;
+    const line = lines[0];
+    const lineChildren = directChildren(line);
+    return hasOnlyAttributes(line, []) && lineChildren.length <= 1 && lineChildren.every((child)=>'solidFill' === child.localName && isSupportedSolidFill(child, false));
+}
+function isSupportedSolidFill(fill, allowAlpha) {
+    if (!hasOnlyAttributes(fill, [])) return false;
+    const children = directChildren(fill);
+    if (1 !== children.length || 'srgbClr' !== children[0].localName) return false;
+    const color = children[0];
+    if (!hasOnlyAttributes(color, [
+        'val'
+    ])) return false;
+    if (!/^[0-9a-f]{6}$/i.test(attribute(color, 'val') ?? '')) return false;
+    const transforms = directChildren(color);
+    if (transforms.some((transform)=>'alpha' !== transform.localName) || transforms.length > (allowAlpha ? 1 : 0)) return false;
+    if (!transforms.length) return true;
+    if (!hasOnlyAttributes(transforms[0], [
+        'val'
+    ])) return false;
+    const alpha = Number(attribute(transforms[0], 'val'));
+    return Number.isInteger(alpha) && alpha >= 0 && alpha <= 100000;
+}
+function hasOnlyAttributes(element, allowed) {
+    return Array.from(element.attributes).every((item)=>'xmlns' === item.name || 'xmlns' === item.prefix || allowed.includes(item.localName));
+}
+const XLSX_CHART_RELATIONSHIP = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart';
+const XLSX_CHART_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.drawingml.chart+xml';
+const RELATIONSHIP_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const CHART_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/chart';
+const DRAWINGML_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+const CHART_GRAPHIC_URI = 'http://schemas.openxmlformats.org/drawingml/2006/chart';
+const SUPPORTED_CHART_ELEMENTS = new Set([
+    'barChart',
+    'lineChart',
+    'pieChart',
+    'doughnutChart',
+    'areaChart',
+    'radarChart',
+    'scatterChart',
+    'bubbleChart'
+]);
+function isSupportedXlsxCombinationChartNodes(chartNodes) {
+    if (chartNodes.length < 2 || !chartNodes.every((node)=>null !== xlsxCombinationSeriesType(node) && isSupportedXlsxCombinationPlotNode(node))) return false;
+    const categoryNodes = chartNodes.flatMap((node)=>directChildren(node, 'ser').map((series)=>directChild(series, 'cat')));
+    if (!categoryNodes.length || categoryNodes.some((category)=>!category)) return false;
+    const signatures = categoryNodes.map((category)=>categorySourceSignature(category));
+    return signatures.every((signature)=>signature === signatures[0]);
+}
+function categorySourceSignature(category) {
+    const reference = formulaReference(category);
+    return reference ? `reference:${reference}` : `literal:${JSON.stringify(cachedValues(category))}`;
+}
+async function readXlsxWorksheetCharts(archive, worksheetPart, worksheet) {
+    const drawingReference = directChildren(worksheet.documentElement, 'drawing')[0];
+    const relationshipId = drawingReference ? attribute(drawingReference, 'r:id') ?? attribute(drawingReference, 'id') : null;
+    if (!relationshipId) return [];
+    const worksheetRelationships = await archive.relationships(worksheetPart);
+    const drawingRelationship = worksheetRelationships.get(relationshipId);
+    if (!drawingRelationship || 'External' === drawingRelationship.targetMode || !drawingRelationship.type.endsWith('/drawing') || !archive.has(drawingRelationship.target)) return [];
+    const drawing = await archive.xml(drawingRelationship.target);
+    const relationships = await archive.relationships(drawingRelationship.target);
+    const charts = [];
+    for (const [anchorIndex, anchor] of directChildren(drawing.documentElement).entries()){
+        if (![
+            'twoCellAnchor',
+            'oneCellAnchor',
+            'absoluteAnchor'
+        ].includes(anchor.localName)) continue;
+        const frame = directChild(anchor, 'graphicFrame');
+        const chartReference = firstDescendant(frame, 'chart');
+        const chartRelationshipId = chartReference ? attribute(chartReference, 'r:id') ?? attribute(chartReference, 'id') : null;
+        const relationship = chartRelationshipId ? relationships.get(chartRelationshipId) : void 0;
+        if (!frame || !relationship || 'External' === relationship.targetMode || !relationship.type.endsWith('/chart') || !archive.has(relationship.target)) continue;
+        const parsed = parseXlsxChart(await archive.xml(relationship.target));
+        if (!parsed) continue;
+        const properties = firstDescendant(frame, 'cNvPr');
+        const sourceId = attribute(properties ?? frame, 'id') ?? String(anchorIndex + 1);
+        charts.push({
+            id: `xlsx-chart-${partNumber(drawingRelationship.target)}-${sourceId}`,
+            name: attribute(properties ?? frame, 'name')?.trim() || `Worksheet chart ${anchorIndex + 1}`,
+            altText: attribute(properties ?? frame, 'descr')?.trim() || void 0,
+            ...parsed,
+            ...readXlsxDrawingAnchor(anchor)
+        });
+    }
+    return charts;
+}
+function xlsxWorksheetChartsToSheet(charts, config) {
+    return charts.flatMap((chart)=>{
+        const bounds = xlsxDrawingAnchorToBounds(chart, config);
+        if (!bounds) return [];
+        return [
+            {
+                ...chart,
+                ...bounds
+            }
+        ];
+    });
+}
+function xlsxChartGraphicFrameXml(chart, relationshipId, objectId, sheet) {
+    return [
+        '<xdr:twoCellAnchor editAs="oneCell">',
+        xlsxTwoCellAnchorMarkers(chart, sheet),
+        '<xdr:graphicFrame macro="">',
+        '<xdr:nvGraphicFramePr>',
+        `<xdr:cNvPr id="${objectId}" name="${escapeXml(chart.name.trim() || `Chart ${objectId}`)}"${chart.altText?.trim() ? ` descr="${escapeXml(chart.altText.trim())}"` : ''}/>`,
+        '<xdr:cNvGraphicFramePr/>',
+        '</xdr:nvGraphicFramePr>',
+        '<xdr:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/></xdr:xfrm>',
+        `<a:graphic><a:graphicData uri="${CHART_GRAPHIC_URI}">`,
+        `<c:chart xmlns:c="${CHART_NAMESPACE}" xmlns:r="${RELATIONSHIP_NAMESPACE}" r:id="${relationshipId}"/>`,
+        '</a:graphicData></a:graphic>',
+        '</xdr:graphicFrame>',
+        '<xdr:clientData/>',
+        '</xdr:twoCellAnchor>'
+    ].join('');
+}
+function xlsxChartPartXml(chart, content, ownerSheet, chartIndex) {
+    const resolved = resolveSpreadsheetChart(content, ownerSheet, chart);
+    const categoryAxisId = 10000000 + 2 * chartIndex;
+    const valueAxisId = categoryAxisId + 1;
+    const secondaryCategoryAxisId = categoryAxisId + 2;
+    const secondaryValueAxisId = categoryAxisId + 3;
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        `<c:chartSpace xmlns:c="${CHART_NAMESPACE}" xmlns:a="${DRAWINGML_NAMESPACE}" xmlns:r="${RELATIONSHIP_NAMESPACE}">`,
+        '<c:date1904 val="0"/><c:lang val="zh-CN"/><c:roundedCorners val="0"/>',
+        '<c:chart>',
+        chartTitleXml(resolved),
+        `<c:autoTitleDeleted val="${resolved.title?.trim() ? 0 : 1}"/>`,
+        '<c:plotArea><c:layout/>',
+        chartPlotXml(resolved, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId),
+        'pie' === resolved.type || 'doughnut' === resolved.type ? '' : chartAxesXml(resolved, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId),
+        '</c:plotArea>',
+        xlsxChartLegendXml(resolved),
+        '<c:plotVisOnly val="1"/><c:dispBlanksAs val="gap"/><c:showDLblsOverMax val="0"/>',
+        '</c:chart>',
+        '<c:printSettings><c:headerFooter/><c:pageMargins b="0.75" l="0.7" r="0.7" t="0.75" header="0.3" footer="0.3"/><c:pageSetup/></c:printSettings>',
+        '</c:chartSpace>'
+    ].join('');
+}
+function parseXlsxChart(document) {
+    const plotArea = firstDescendant(document, 'plotArea');
+    if (!plotArea) return null;
+    const chartNodes = directChildren(plotArea).filter((element)=>/Chart$/i.test(element.localName));
+    if (isSupportedXlsxCombinationChartNodes(chartNodes)) return parseXlsxCombinationChart(document, chartNodes);
+    if (1 !== chartNodes.length || !SUPPORTED_CHART_ELEMENTS.has(chartNodes[0].localName)) return null;
+    const chartNode = chartNodes[0];
+    const type = xlsxChartType(chartNode);
+    const seriesNodes = directChildren(chartNode, 'ser');
+    if (!seriesNodes.length) return null;
+    const chartDataLabels = parseXlsxDataLabels(directChild(chartNode, 'dLbls'), type);
+    const parsedSeries = seriesNodes.map((node, index)=>parseXlsxChartSeries(node, index, type, chartDataLabels));
+    const series = xlsxChartNodeUsesStackedGrouping(chartNode) ? parsedSeries.map(withoutStackedChartAnalysis) : parsedSeries;
+    const categoryNode = workSpreadsheetChartUsesNumericXAxis(type) ? null : directChild(seriesNodes[0], 'cat');
+    const title = xlsxChartTitle(document);
+    const axes = parseXlsxChartAxes(document, type, false);
+    const legend = parseXlsxChartLegend(document);
+    const layout = parseXlsxChartPlotLayout(chartNode, type);
+    return {
+        type,
+        title: title ? cachedText(title) || richText(title) || void 0 : void 0,
+        titleReference: title ? formulaReference(title) : void 0,
+        categories: categoryNode ? cachedValues(categoryNode) : [],
+        categoryReference: categoryNode ? formulaReference(categoryNode) : void 0,
+        series,
+        ...legend,
+        ...layout,
+        ...axes ? {
+            axes
+        } : {},
+        ...'doughnut' === type ? {
+            doughnutHoleSize: readDoughnutHoleSize(chartNode)
+        } : {},
+        ...'radar' === type ? {
+            radarStyle: readRadarStyle(chartNode)
+        } : {},
+        ...'scatter' === type ? {
+            scatterStyle: readScatterStyle(chartNode)
+        } : {},
+        ...'bubble' === type ? {
+            bubbleScale: readBubbleScale(chartNode),
+            showNegativeBubbles: readShowNegativeBubbles(chartNode),
+            bubbleSizeRepresents: readBubbleSizeRepresents(chartNode)
+        } : {}
+    };
+}
+function parseXlsxCombinationChart(document, chartNodes) {
+    const entries = chartNodes.flatMap((chartNode)=>{
+        const chartType = xlsxCombinationSeriesType(chartNode);
+        if (!chartType) return [];
+        const axisGroup = xlsxCombinationAxisGroup(document, chartNode);
+        const chartDataLabels = parseXlsxDataLabels(directChild(chartNode, 'dLbls'), chartType);
+        return directChildren(chartNode, 'ser').map((seriesNode, sourceIndex)=>({
+                seriesNode,
+                chartType,
+                axisGroup,
+                chartDataLabels,
+                order: finiteNumber(attribute(directChild(seriesNode, 'order') ?? seriesNode, 'val') ?? sourceIndex, sourceIndex)
+            }));
+    }).sort((left, right)=>left.order - right.order);
+    if (!entries.length) return null;
+    const categoryNode = directChild(entries[0].seriesNode, 'cat');
+    const title = xlsxChartTitle(document);
+    const hasSecondaryAxes = entries.some((entry)=>'secondary' === entry.axisGroup);
+    const axes = parseXlsxChartAxes(document, 'combination', hasSecondaryAxes);
+    const legend = parseXlsxChartLegend(document);
+    return {
+        type: 'combination',
+        title: title ? cachedText(title) || richText(title) || void 0 : void 0,
+        titleReference: title ? formulaReference(title) : void 0,
+        categories: categoryNode ? cachedValues(categoryNode) : [],
+        categoryReference: categoryNode ? formulaReference(categoryNode) : void 0,
+        series: entries.map((entry, index)=>({
+                ...parseXlsxChartSeries(entry.seriesNode, index, entry.chartType, entry.chartDataLabels),
+                chartType: entry.chartType,
+                axisGroup: entry.axisGroup
+            })),
+        ...legend,
+        ...axes ? {
+            axes
+        } : {}
+    };
+}
+function withoutStackedChartAnalysis(series) {
+    const editable = {
+        ...series
+    };
+    delete editable.errorBars;
+    delete editable.trendlines;
+    return editable;
+}
+function xlsxChartTitle(document) {
+    const chart = directChild(document.documentElement, 'chart') ?? firstDescendant(document, 'chart');
+    return chart ? directChild(chart, 'title') : void 0;
+}
+function xlsxCombinationSeriesType(node) {
+    if ('lineChart' === node.localName) return 'line';
+    if ('areaChart' === node.localName) return 'area';
+    if ('barChart' === node.localName && 'bar' !== attribute(firstDescendant(node, 'barDir') ?? node, 'val')) return 'column';
+    return null;
+}
+function xlsxCombinationAxisGroup(document, chartNode) {
+    const axisIds = new Set(directChildren(chartNode, 'axId').map((axis)=>attribute(axis, 'val')).filter((value)=>Boolean(value)));
+    const usesRightAxis = descendants(document, 'valAx').some((axis)=>{
+        const axisId = attribute(firstDescendant(axis, 'axId') ?? axis, 'val');
+        const position = attribute(firstDescendant(axis, 'axPos') ?? axis, 'val');
+        return Boolean(axisId && axisIds.has(axisId) && 'r' === position);
+    });
+    return usesRightAxis ? 'secondary' : 'primary';
+}
+function parseXlsxChartSeries(node, index, type, inheritedDataLabels) {
+    const title = directChild(node, 'tx');
+    const values = directChild(node, workSpreadsheetChartUsesNumericXAxis(type) ? 'yVal' : 'val');
+    const xValues = workSpreadsheetChartUsesNumericXAxis(type) ? directChild(node, 'xVal') : null;
+    const bubbleSizes = 'bubble' === type ? directChild(node, 'bubbleSize') : null;
+    const dataLabelsNode = directChild(node, 'dLbls');
+    const dataLabels = dataLabelsNode ? parseXlsxDataLabels(dataLabelsNode, type) : inheritedDataLabels;
+    const errorBars = workSpreadsheetChartSupportsErrorBars(type) ? directChildren(node, 'errBars').flatMap((errorBarNode)=>{
+        const parsed = parseXlsxErrorBars(errorBarNode, type);
+        return parsed ? [
+            parsed
+        ] : [];
+    }) : [];
+    const trendlines = workSpreadsheetChartSupportsTrendlines(type) ? directChildren(node, 'trendline').flatMap((trendline)=>{
+        const parsed = parseXlsxTrendline(trendline);
+        return parsed ? [
+            parsed
+        ] : [];
+    }) : [];
+    const style = parseXlsxChartSeriesStyle(node);
+    return {
+        name: (title ? cachedText(title) || richText(title) : '') || `Series ${index + 1}`,
+        nameReference: title ? formulaReference(title) : void 0,
+        values: values ? cachedValues(values).map((value)=>finiteNumber(value)) : [],
+        valuesReference: values ? formulaReference(values) : void 0,
+        ...xValues ? {
+            xValues: cachedValues(xValues).map((value)=>finiteNumber(value)),
+            xValuesReference: formulaReference(xValues)
+        } : {},
+        ...bubbleSizes ? {
+            bubbleSizes: cachedValues(bubbleSizes).map((value)=>finiteNumber(value)),
+            bubbleSizesReference: formulaReference(bubbleSizes)
+        } : {},
+        ...dataLabels ? {
+            dataLabels: {
+                ...dataLabels
+            }
+        } : {},
+        ...errorBars.length ? {
+            errorBars
+        } : {},
+        ...trendlines.length ? {
+            trendlines
+        } : {},
+        ...style ? {
+            style
+        } : {}
+    };
+}
+function parseXlsxDataLabels(node, chartType) {
+    if (!node || xlsxBooleanElement(node, 'delete')) return;
+    const separatorElement = directChild(node, 'separator');
+    const position = xlsxDataLabelPosition(attribute(directChild(node, 'dLblPos') ?? node, 'val'));
+    return normalizeWorkSpreadsheetDataLabels({
+        ...xlsxBooleanElement(node, 'showVal') ? {
+            showValue: true
+        } : {},
+        ...xlsxBooleanElement(node, 'showCatName') ? {
+            showCategoryName: true
+        } : {},
+        ...xlsxBooleanElement(node, 'showSerName') ? {
+            showSeriesName: true
+        } : {},
+        ...xlsxBooleanElement(node, 'showPercent') ? {
+            showPercentage: true
+        } : {},
+        ...xlsxBooleanElement(node, 'showBubbleSize') ? {
+            showBubbleSize: true
+        } : {},
+        ...separatorElement ? {
+            separator: separatorElement.textContent ?? ''
+        } : {},
+        ...position ? {
+            position
+        } : {}
+    }, chartType);
+}
+function xlsxDataLabelPosition(value) {
+    if ('ctr' === value) return 'center';
+    if ('inBase' === value) return 'insideBase';
+    if ('inEnd' === value) return 'insideEnd';
+    if ('outEnd' === value) return 'outsideEnd';
+    if ('l' === value) return 'left';
+    if ('r' === value) return 'right';
+    if ('t' === value) return 'above';
+    if ('b' === value) return 'below';
+    if ('bestFit' === value) return 'bestFit';
+}
+function xlsxBooleanElement(parent, localName) {
+    const element = directChild(parent, localName);
+    if (!element) return false;
+    const value = attribute(element, 'val');
+    return null === value || work_xlsx_charts_readBooleanValue(value);
+}
+function parseXlsxErrorBars(node, chartType) {
+    if (!workSpreadsheetChartSupportsErrorBars(chartType)) return null;
+    const directionValue = attribute(directChild(node, 'errDir') ?? node, 'val');
+    const direction = 'x' === directionValue ? 'x' : 'y' === directionValue ? 'y' : null;
+    if (!direction || 'x' === direction && !workSpreadsheetChartUsesNumericXAxis(chartType)) return null;
+    const barTypeValue = attribute(directChild(node, 'errBarType') ?? node, 'val');
+    const barType = 'plus' === barTypeValue || 'minus' === barTypeValue || 'both' === barTypeValue ? barTypeValue : null;
+    const valueType = workSpreadsheetErrorBarValueType(attribute(directChild(node, 'errValType') ?? node, 'val'));
+    if (!barType || !valueType) return null;
+    const value = numericElementValue(node, 'val');
+    const plus = directChild(node, 'plus');
+    const minus = directChild(node, 'minus');
+    return normalizeWorkSpreadsheetErrorBars({
+        direction,
+        barType,
+        valueType,
+        ...void 0 !== value ? {
+            value
+        } : {},
+        ...xlsxBooleanElement(node, 'noEndCap') ? {
+            showEndCaps: false
+        } : {},
+        ...plus ? {
+            plusValues: cachedValues(plus).map((item)=>finiteNumber(item)),
+            plusReference: formulaReference(plus)
+        } : {},
+        ...minus ? {
+            minusValues: cachedValues(minus).map((item)=>finiteNumber(item)),
+            minusReference: formulaReference(minus)
+        } : {}
+    }, chartType);
+}
+function workSpreadsheetErrorBarValueType(value) {
+    if ('fixedVal' === value) return 'fixedValue';
+    if ('percentage' === value) return 'percentage';
+    if ('stdDev' === value) return 'standardDeviation';
+    if ('stdErr' === value) return 'standardError';
+    if ('cust' === value) return 'custom';
+    return null;
+}
+function parseXlsxTrendline(node) {
+    const type = xlsxTrendlineType(attribute(firstDescendant(node, 'trendlineType') ?? node, 'val'));
+    if (!type) return null;
+    const name = directChild(node, 'name')?.textContent?.trim();
+    const order = numericElementValue(node, 'order');
+    const period = numericElementValue(node, 'period');
+    const forward = numericElementValue(node, 'forward');
+    const backward = numericElementValue(node, 'backward');
+    const intercept = numericElementValue(node, 'intercept');
+    return normalizeWorkSpreadsheetTrendline({
+        type,
+        ...name ? {
+            name
+        } : {},
+        ...void 0 !== order ? {
+            order
+        } : {},
+        ...void 0 !== period ? {
+            period
+        } : {},
+        ...void 0 !== forward ? {
+            forward
+        } : {},
+        ...void 0 !== backward ? {
+            backward
+        } : {},
+        ...void 0 !== intercept ? {
+            intercept
+        } : {},
+        ...xlsxBooleanElement(node, 'dispEq') ? {
+            displayEquation: true
+        } : {},
+        ...xlsxBooleanElement(node, 'dispRSq') ? {
+            displayRSquared: true
+        } : {}
+    });
+}
+function xlsxTrendlineType(value) {
+    if ('exp' === value) return 'exponential';
+    if ('log' === value) return 'logarithmic';
+    if ('poly' === value) return 'polynomial';
+    if ('power' === value) return 'power';
+    if ('movingAvg' === value) return 'movingAverage';
+    if ('linear' === value) return 'linear';
+    return null;
+}
+function numericElementValue(parent, localName) {
+    const element = firstDescendant(parent, localName);
+    if (!element) return;
+    const value = Number(attribute(element, 'val'));
+    return Number.isFinite(value) ? value : void 0;
+}
+function xlsxChartType(node) {
+    if ('lineChart' === node.localName) return 'line';
+    if ('pieChart' === node.localName) return 'pie';
+    if ('doughnutChart' === node.localName) return 'doughnut';
+    if ('areaChart' === node.localName) return 'area';
+    if ('radarChart' === node.localName) return 'radar';
+    if ('scatterChart' === node.localName) return 'scatter';
+    if ('bubbleChart' === node.localName) return 'bubble';
+    return 'bar' === attribute(firstDescendant(node, 'barDir') ?? node, 'val') ? 'bar' : 'column';
+}
+function readDoughnutHoleSize(node) {
+    return normalizeWorkSpreadsheetDoughnutHoleSize(attribute(firstDescendant(node, 'holeSize') ?? node, 'val'));
+}
+function readRadarStyle(node) {
+    return normalizeWorkSpreadsheetRadarStyle(attribute(firstDescendant(node, 'radarStyle') ?? node, 'val'));
+}
+function readScatterStyle(node) {
+    return normalizeWorkSpreadsheetScatterStyle(attribute(firstDescendant(node, 'scatterStyle') ?? node, 'val'));
+}
+function readBubbleScale(node) {
+    return normalizeWorkSpreadsheetBubbleScale(attribute(firstDescendant(node, 'bubbleScale') ?? node, 'val'));
+}
+function readShowNegativeBubbles(node) {
+    return work_xlsx_charts_readBooleanValue(attribute(firstDescendant(node, 'showNegBubbles') ?? node, 'val'));
+}
+function readBubbleSizeRepresents(node) {
+    return normalizeWorkSpreadsheetBubbleSizeRepresents(attribute(firstDescendant(node, 'sizeRepresents') ?? node, 'val'));
+}
+function chartTitleXml(chart) {
+    const title = chart.title?.trim();
+    if (!title && !chart.titleReference?.trim()) return '';
+    return chartTextTitleXml(title ?? '', chart.titleReference);
+}
+function chartPlotXml(chart, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId) {
+    if ('combination' === chart.type) return combinationChartPlotXml(chart, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId);
+    const series = chart.series.map((item, index)=>workSpreadsheetChartUsesNumericXAxis(chart.type) ? xyChartSeriesXml(item, chart, index) : chartSeriesXml(item, chart, index)).join('');
+    if ('pie' === chart.type) return `<c:pieChart><c:varyColors val="1"/>${series}<c:firstSliceAng val="0"/></c:pieChart>`;
+    if ('doughnut' === chart.type) {
+        const holeSize = normalizeWorkSpreadsheetDoughnutHoleSize(chart.doughnutHoleSize);
+        return `<c:doughnutChart><c:varyColors val="1"/>${series}<c:firstSliceAng val="0"/><c:holeSize val="${holeSize}"/></c:doughnutChart>`;
+    }
+    const axes = `<c:axId val="${categoryAxisId}"/><c:axId val="${valueAxisId}"/>`;
+    if ('line' === chart.type) return `<c:lineChart><c:grouping val="${xlsxChartGroupingValue(chart)}"/><c:varyColors val="0"/>${series}<c:marker val="1"/><c:smooth val="${xlsxChartSmoothLinesValue(chart) ? 1 : 0}"/>${axes}</c:lineChart>`;
+    if ('area' === chart.type) return `<c:areaChart><c:grouping val="${xlsxChartGroupingValue(chart)}"/><c:varyColors val="0"/>${series}${axes}</c:areaChart>`;
+    if ('radar' === chart.type) {
+        const style = normalizeWorkSpreadsheetRadarStyle(chart.radarStyle);
+        return `<c:radarChart><c:radarStyle val="${style}"/><c:varyColors val="0"/>${series}${axes}</c:radarChart>`;
+    }
+    if ('scatter' === chart.type) {
+        const style = normalizeWorkSpreadsheetScatterStyle(chart.scatterStyle);
+        return `<c:scatterChart><c:scatterStyle val="${style}"/><c:varyColors val="0"/>${series}${axes}</c:scatterChart>`;
+    }
+    if ('bubble' === chart.type) {
+        const scale = normalizeWorkSpreadsheetBubbleScale(chart.bubbleScale);
+        const showNegative = true === chart.showNegativeBubbles ? 1 : 0;
+        const sizeRepresents = 'width' === normalizeWorkSpreadsheetBubbleSizeRepresents(chart.bubbleSizeRepresents) ? 'w' : 'area';
+        return `<c:bubbleChart><c:varyColors val="0"/>${series}<c:bubble3D val="0"/><c:bubbleScale val="${scale}"/><c:showNegBubbles val="${showNegative}"/><c:sizeRepresents val="${sizeRepresents}"/>${axes}</c:bubbleChart>`;
+    }
+    const direction = 'bar' === chart.type ? 'bar' : 'col';
+    return `<c:barChart><c:barDir val="${direction}"/><c:grouping val="${xlsxChartGroupingValue(chart)}"/><c:varyColors val="0"/>${series}<c:gapWidth val="${xlsxChartGapWidthValue(chart)}"/><c:overlap val="${xlsxChartOverlapValue(chart)}"/>${axes}</c:barChart>`;
+}
+function combinationChartPlotXml(chart, categoryAxisId, valueAxisId, secondaryCategoryAxisId, secondaryValueAxisId) {
+    const groups = new Map();
+    chart.series.forEach((item, index)=>{
+        const type = normalizeWorkSpreadsheetCombinationSeriesType(item.chartType);
+        const axisGroup = normalizeWorkSpreadsheetChartAxisGroup(item.axisGroup);
+        const key = `${type}:${axisGroup}`;
+        const group = groups.get(key) ?? {
+            type,
+            axisGroup,
+            series: []
+        };
+        group.series.push({
+            item,
+            index
+        });
+        groups.set(key, group);
+    });
+    return Array.from(groups.values()).map((group)=>{
+        const axes = 'secondary' === group.axisGroup ? `<c:axId val="${secondaryCategoryAxisId}"/><c:axId val="${secondaryValueAxisId}"/>` : `<c:axId val="${categoryAxisId}"/><c:axId val="${valueAxisId}"/>`;
+        const seriesChart = {
+            ...chart,
+            type: group.type,
+            grouping: 'column' === group.type ? 'clustered' : 'standard',
+            gapWidth: 'column' === group.type ? 150 : void 0,
+            overlap: 'column' === group.type ? 0 : void 0,
+            smoothLines: false
+        };
+        const series = group.series.map(({ item, index })=>chartSeriesXml(item, seriesChart, index)).join('');
+        if ('line' === group.type) return `<c:lineChart><c:grouping val="standard"/><c:varyColors val="0"/>${series}<c:marker val="1"/><c:smooth val="0"/>${axes}</c:lineChart>`;
+        if ('area' === group.type) return `<c:areaChart><c:grouping val="standard"/><c:varyColors val="0"/>${series}${axes}</c:areaChart>`;
+        return `<c:barChart><c:barDir val="col"/><c:grouping val="clustered"/><c:varyColors val="0"/>${series}<c:gapWidth val="150"/><c:overlap val="0"/>${axes}</c:barChart>`;
+    }).join('');
+}
+function chartSeriesXml(series, chart, index) {
+    const title = chartSeriesTitleXml(series, index);
+    const categories = chart.categoryReference?.trim() ? `<c:strRef><c:f>${escapeXml(chart.categoryReference.replace(/^=/, ''))}</c:f>${stringCacheXml(chart.categories)}</c:strRef>` : stringLiteralXml(chart.categories);
+    const values = series.valuesReference?.trim() ? `<c:numRef><c:f>${escapeXml(series.valuesReference.replace(/^=/, ''))}</c:f>${numberCacheXml(series.values)}</c:numRef>` : numberLiteralXml(series.values);
+    const showMarkers = 'line' === chart.type || 'radar' === chart.type && 'marker' === normalizeWorkSpreadsheetRadarStyle(chart.radarStyle);
+    const shapeProperties = xlsxChartSeriesShapePropertiesXml(series.style);
+    const marker = 'line' === chart.type || 'radar' === chart.type ? xlsxChartSeriesMarkerXml(series.style, showMarkers) : '';
+    const dataLabels = chartDataLabelsXml(series, chart.type);
+    const supportsAnalysis = !xlsxChartGroupingIsStacked(chart);
+    const trendlines = supportsAnalysis && workSpreadsheetChartSupportsTrendlines(chart.type) ? chartTrendlinesXml(series) : '';
+    const errorBars = supportsAnalysis ? chartErrorBarsXml(series, chart.type) : '';
+    return [
+        '<c:ser>',
+        `<c:idx val="${index}"/><c:order val="${index}"/>`,
+        `<c:tx>${title}</c:tx>`,
+        shapeProperties,
+        marker,
+        dataLabels,
+        trendlines,
+        errorBars,
+        `<c:cat>${categories}</c:cat><c:val>${values}</c:val>`,
+        'line' === chart.type ? `<c:smooth val="${xlsxChartSmoothLinesValue(chart) ? 1 : 0}"/>` : '',
+        '</c:ser>'
+    ].join('');
+}
+function xyChartSeriesXml(series, chart, index) {
+    const title = chartSeriesTitleXml(series, index);
+    const xValues = series.xValues?.length ? series.xValues : Array.from({
+        length: series.values.length
+    }, (_, valueIndex)=>valueIndex + 1);
+    const xValuesXml = numberReferenceOrLiteralXml(series.xValuesReference, xValues);
+    const yValuesXml = numberReferenceOrLiteralXml(series.valuesReference, series.values);
+    const dataLabels = chartDataLabelsXml(series, chart.type);
+    const trendlines = chartTrendlinesXml(series);
+    const errorBars = chartErrorBarsXml(series, chart.type);
+    const shapeProperties = xlsxChartSeriesShapePropertiesXml(series.style);
+    if ('bubble' === chart.type) {
+        const bubbleSizesXml = numberReferenceOrLiteralXml(series.bubbleSizesReference, series.bubbleSizes ?? []);
+        return [
+            '<c:ser>',
+            `<c:idx val="${index}"/><c:order val="${index}"/>`,
+            `<c:tx>${title}</c:tx>`,
+            shapeProperties,
+            dataLabels,
+            trendlines,
+            errorBars,
+            `<c:xVal>${xValuesXml}</c:xVal><c:yVal>${yValuesXml}</c:yVal>`,
+            `<c:bubbleSize>${bubbleSizesXml}</c:bubbleSize><c:bubble3D val="0"/>`,
+            '</c:ser>'
+        ].join('');
+    }
+    const style = normalizeWorkSpreadsheetScatterStyle(chart.scatterStyle);
+    const showMarkers = 'marker' === style || 'lineMarker' === style || 'smoothMarker' === style;
+    const smooth = 'smooth' === style || 'smoothMarker' === style;
+    return [
+        '<c:ser>',
+        `<c:idx val="${index}"/><c:order val="${index}"/>`,
+        `<c:tx>${title}</c:tx>`,
+        shapeProperties,
+        xlsxChartSeriesMarkerXml(series.style, showMarkers),
+        dataLabels,
+        trendlines,
+        errorBars,
+        `<c:xVal>${xValuesXml}</c:xVal><c:yVal>${yValuesXml}</c:yVal>`,
+        `<c:smooth val="${smooth ? 1 : 0}"/>`,
+        '</c:ser>'
+    ].join('');
+}
+function chartDataLabelsXml(series, chartType) {
+    if (!series.dataLabels) return '';
+    const labels = normalizeWorkSpreadsheetDataLabels(series.dataLabels, chartType);
+    return [
+        '<c:dLbls>',
+        labels.position ? `<c:dLblPos val="${xlsxDataLabelPositionValue(labels.position)}"/>` : '',
+        '<c:showLegendKey val="0"/>',
+        `<c:showVal val="${labels.showValue ? 1 : 0}"/>`,
+        `<c:showCatName val="${labels.showCategoryName ? 1 : 0}"/>`,
+        `<c:showSerName val="${labels.showSeriesName ? 1 : 0}"/>`,
+        `<c:showPercent val="${labels.showPercentage ? 1 : 0}"/>`,
+        `<c:showBubbleSize val="${labels.showBubbleSize ? 1 : 0}"/>`,
+        void 0 !== labels.separator ? `<c:separator>${escapeXml(labels.separator)}</c:separator>` : '',
+        '<c:showLeaderLines val="0"/>',
+        '</c:dLbls>'
+    ].join('');
+}
+function xlsxDataLabelPositionValue(position) {
+    if ('center' === position) return 'ctr';
+    if ('insideBase' === position) return 'inBase';
+    if ('insideEnd' === position) return 'inEnd';
+    if ('outsideEnd' === position) return 'outEnd';
+    if ('left' === position) return 'l';
+    if ('right' === position) return 'r';
+    if ('above' === position) return 't';
+    if ('below' === position) return 'b';
+    return 'bestFit';
+}
+function chartTrendlinesXml(series) {
+    return (series.trendlines ?? []).map(chartTrendlineXml).join('');
+}
+function chartErrorBarsXml(series, chartType) {
+    if (!workSpreadsheetChartSupportsErrorBars(chartType)) return '';
+    const directions = new Set();
+    return (series.errorBars ?? []).flatMap((source)=>{
+        if ('x' === source.direction && !workSpreadsheetChartUsesNumericXAxis(chartType)) return [];
+        const errorBars = normalizeWorkSpreadsheetErrorBars(source, chartType);
+        if (directions.has(errorBars.direction)) return [];
+        directions.add(errorBars.direction);
+        return [
+            chartErrorBarXml(errorBars)
+        ];
+    }).join('');
+}
+function chartErrorBarXml(errorBars) {
+    const plus = 'custom' === errorBars.valueType && 'minus' !== errorBars.barType ? chartCustomErrorBarSourceXml('plus', errorBars.plusReference, errorBars.plusValues) : '';
+    const minus = 'custom' === errorBars.valueType && 'plus' !== errorBars.barType ? chartCustomErrorBarSourceXml('minus', errorBars.minusReference, errorBars.minusValues) : '';
+    const value = 'fixedValue' === errorBars.valueType || 'percentage' === errorBars.valueType || 'standardDeviation' === errorBars.valueType ? `<c:val val="${finiteNumber(errorBars.value, 'percentage' === errorBars.valueType ? 5 : 1)}"/>` : '';
+    return [
+        '<c:errBars>',
+        `<c:errDir val="${errorBars.direction}"/>`,
+        `<c:errBarType val="${errorBars.barType}"/>`,
+        `<c:errValType val="${xlsxErrorBarValueType(errorBars.valueType)}"/>`,
+        false === errorBars.showEndCaps ? '<c:noEndCap val="1"/>' : '',
+        plus,
+        minus,
+        value,
+        '</c:errBars>'
+    ].join('');
+}
+function chartCustomErrorBarSourceXml(localName, reference, values) {
+    if (!reference?.trim() && !values?.length) return '';
+    return `<c:${localName}>${numberReferenceOrLiteralXml(reference, values ?? [])}</c:${localName}>`;
+}
+function xlsxErrorBarValueType(type) {
+    if ('fixedValue' === type) return 'fixedVal';
+    if ('standardDeviation' === type) return 'stdDev';
+    if ('standardError' === type) return 'stdErr';
+    if ('custom' === type) return 'cust';
+    return 'percentage';
+}
+function chartTrendlineXml(source) {
+    const trendline = normalizeWorkSpreadsheetTrendline(source);
+    const type = xlsxTrendlineTypeValue(trendline.type);
+    return [
+        '<c:trendline>',
+        trendline.name ? `<c:name>${escapeXml(trendline.name)}</c:name>` : '',
+        `<c:trendlineType val="${type}"/>`,
+        'polynomial' === trendline.type ? `<c:order val="${trendline.order ?? 2}"/>` : '',
+        'movingAverage' === trendline.type ? `<c:period val="${trendline.period ?? 2}"/>` : '',
+        trendline.forward ? `<c:forward val="${finiteNumber(trendline.forward)}"/>` : '',
+        trendline.backward ? `<c:backward val="${finiteNumber(trendline.backward)}"/>` : '',
+        void 0 !== trendline.intercept ? `<c:intercept val="${finiteNumber(trendline.intercept)}"/>` : '',
+        trendline.displayRSquared ? '<c:dispRSq val="1"/>' : '',
+        trendline.displayEquation ? '<c:dispEq val="1"/>' : '',
+        '</c:trendline>'
+    ].join('');
+}
+function xlsxTrendlineTypeValue(type) {
+    if ('exponential' === type) return 'exp';
+    if ('logarithmic' === type) return 'log';
+    if ('polynomial' === type) return 'poly';
+    if ('movingAverage' === type) return 'movingAvg';
+    return type;
+}
+function chartSeriesTitleXml(series, index) {
+    return series.nameReference?.trim() ? `<c:strRef><c:f>${escapeXml(series.nameReference.replace(/^=/, ''))}</c:f>${stringCacheXml([
+        series.name
+    ])}</c:strRef>` : `<c:v>${escapeXml(series.name || `Series ${index + 1}`)}</c:v>`;
+}
+function numberReferenceOrLiteralXml(reference, values) {
+    return reference?.trim() ? `<c:numRef><c:f>${escapeXml(reference.replace(/^=/, ''))}</c:f>${numberCacheXml(values)}</c:numRef>` : numberLiteralXml(values);
+}
+function work_xlsx_charts_readBooleanValue(value) {
+    return '1' === value || 'true' === value;
+}
+function partNumber(path) {
+    return /(\d+)(?:\.xml)?$/i.exec(path)?.[1] ?? '1';
+}
+const MAX_XLSX_WORKSHEET_IMAGE_BYTES = 10485760;
+const DRAWING_RELATIONSHIP = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing';
+const IMAGE_RELATIONSHIP = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image';
+const work_xlsx_images_RELATIONSHIP_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const PACKAGE_RELATIONSHIP_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing';
+const work_xlsx_images_DRAWINGML_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+const DRAWING_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.drawing+xml';
+const SUPPORTED_IMAGE_TYPES = new Set([
+    'image/bmp',
+    'image/gif',
+    'image/jpeg',
+    'image/png',
+    'image/svg+xml',
+    'image/webp'
+]);
+function isSupportedXlsxWorksheetImageContentType(contentType) {
+    return SUPPORTED_IMAGE_TYPES.has(contentType.toLowerCase());
+}
+async function readXlsxWorksheetImages(archive, worksheetPart, worksheet, imageBudget) {
+    const drawingReference = directChildren(worksheet.documentElement, 'drawing')[0];
+    const relationshipId = drawingReference ? attribute(drawingReference, 'r:id') ?? attribute(drawingReference, 'id') : null;
+    if (!relationshipId) return [];
+    const worksheetRelationships = await archive.relationships(worksheetPart);
+    const drawingRelationship = worksheetRelationships.get(relationshipId);
+    if (!drawingRelationship || 'External' === drawingRelationship.targetMode || !drawingRelationship.type.endsWith('/drawing') || !archive.has(drawingRelationship.target)) return [];
+    const drawing = await archive.xml(drawingRelationship.target);
+    const relationships = await archive.relationships(drawingRelationship.target);
+    const images = [];
+    for (const [anchorIndex, anchor] of directChildren(drawing.documentElement).entries()){
+        if (![
+            'twoCellAnchor',
+            'oneCellAnchor',
+            'absoluteAnchor'
+        ].includes(anchor.localName)) continue;
+        const picture = directChild(anchor, 'pic');
+        const blip = firstDescendant(picture, 'blip');
+        const imageRelationshipId = blip ? attribute(blip, 'r:embed') ?? attribute(blip, 'embed') : null;
+        const imageRelationship = imageRelationshipId ? relationships.get(imageRelationshipId) : void 0;
+        if (!picture || !imageRelationship || !readableImageRelationship(archive, imageRelationship)) continue;
+        const contentType = contentTypeForPart(imageRelationship.target);
+        if (!isSupportedXlsxWorksheetImageContentType(contentType)) continue;
+        const bytes = await archive.bytes(imageRelationship.target);
+        if (imageBudget.bytes + bytes.byteLength > MAX_XLSX_WORKSHEET_IMAGE_BYTES) continue;
+        imageBudget.bytes += bytes.byteLength;
+        const properties = firstDescendant(picture, 'cNvPr');
+        const sourceId = attribute(properties ?? picture, 'id') ?? String(anchorIndex + 1);
+        const drawingNumber = work_xlsx_images_partNumber(drawingRelationship.target);
+        images.push({
+            id: `xlsx-image-${drawingNumber}-${sourceId}`,
+            name: attribute(properties ?? picture, 'name')?.trim() || `Worksheet image ${anchorIndex + 1}`,
+            altText: attribute(properties ?? picture, 'descr')?.trim() || void 0,
+            contentType,
+            dataUrl: bytesToDataUrl(bytes, contentType),
+            ...readXlsxDrawingAnchor(anchor)
+        });
+    }
+    return images;
+}
+function xlsxWorksheetImagesToSheet(images, config) {
+    return images.flatMap((image)=>{
+        const bounds = xlsxDrawingAnchorToBounds(image, config);
+        if (!bounds) return [];
+        return [
+            {
+                id: image.id,
+                name: image.name,
+                altText: image.altText,
+                contentType: image.contentType,
+                src: image.dataUrl,
+                ...bounds
+            }
+        ];
+    });
+}
+async function patchXlsxWorksheetDrawings(buffer, content) {
+    if (!content.sheets.some((sheet)=>sheet.images?.some((image)=>serializableImage(image)) || (sheet.charts?.length ?? 0) > 0)) return buffer;
+    const archive = await work_ooxml_package_OoxmlPackage.load(buffer);
+    const worksheetParts = await exportedWorksheetParts(archive);
+    const zip = await jszip.loadAsync(buffer);
+    const drawingPaths = [];
+    const chartPaths = [];
+    const imageTypes = new Map();
+    let drawingIndex = 1;
+    let mediaIndex = 1;
+    let chartIndex = 1;
+    for (const sheet of content.sheets){
+        const images = (sheet.images ?? []).flatMap((image)=>{
+            const data = serializableImage(image);
+            return data ? [
+                {
+                    image,
+                    data
+                }
+            ] : [];
+        });
+        const charts = sheet.charts ?? [];
+        if (!images.length && !charts.length) continue;
+        const worksheetPart = worksheetParts.get(sheet.name.slice(0, 31) || '工作表');
+        const worksheetEntry = worksheetPart ? zip.file(worksheetPart) : null;
+        if (!worksheetPart || !worksheetEntry) continue;
+        const drawingPath = `xl/drawings/drawing${drawingIndex}.xml`;
+        const drawingRelationshipsPath = `xl/drawings/_rels/drawing${drawingIndex}.xml.rels`;
+        drawingIndex += 1;
+        const media = images.map(({ image, data }, index)=>{
+            const path = `xl/media/image${mediaIndex}.${data.extension}`;
+            mediaIndex += 1;
+            imageTypes.set(data.extension, data.contentType);
+            zip.file(path, data.bytes);
+            return {
+                image,
+                path,
+                relationshipId: `rId${index + 1}`,
+                objectId: index + 1
+            };
+        });
+        const chartParts = charts.map((chart, index)=>{
+            const path = `xl/charts/chart${chartIndex}.xml`;
+            const currentChartIndex = chartIndex;
+            chartIndex += 1;
+            chartPaths.push(path);
+            zip.file(path, xlsxChartPartXml(chart, content, sheet, currentChartIndex));
+            return {
+                chart,
+                path,
+                relationshipId: `rId${media.length + index + 1}`,
+                objectId: media.length + index + 1
+            };
+        });
+        zip.file(drawingPath, drawingXml(media, chartParts, sheet));
+        zip.file(drawingRelationshipsPath, drawingRelationshipsXml(media, chartParts));
+        drawingPaths.push(drawingPath);
+        await bindDrawingToWorksheet(zip, worksheetPart, worksheetEntry, drawingPath);
+    }
+    await updateContentTypes(zip, drawingPaths, chartPaths, imageTypes);
+    return zip.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function readableImageRelationship(archive, relationship) {
+    return 'External' !== relationship.targetMode && relationship.type.endsWith('/image') && archive.has(relationship.target);
+}
+function serializableImage(image) {
+    const match = /^data:([^;,]+);base64,([a-z0-9+/=\s]+)$/i.exec(image.src);
+    if (!match) return null;
+    const contentType = image.contentType?.toLowerCase() || match[1].toLowerCase();
+    const extension = imageExtension(contentType);
+    if (!extension || !isSupportedXlsxWorksheetImageContentType(contentType)) return null;
+    try {
+        const binary = atob(match[2].replace(/\s+/g, ''));
+        return {
+            contentType,
+            extension,
+            bytes: Uint8Array.from(binary, (character)=>character.charCodeAt(0))
+        };
+    } catch  {
+        return null;
+    }
+}
+function imageExtension(contentType) {
+    const extensions = {
+        'image/bmp': 'bmp',
+        'image/gif': 'gif',
+        'image/jpeg': 'jpeg',
+        'image/png': 'png',
+        'image/svg+xml': 'svg',
+        'image/webp': 'webp'
+    };
+    return extensions[contentType] ?? null;
+}
+async function exportedWorksheetParts(archive) {
+    if (!archive.has('xl/workbook.xml')) return new Map();
+    const workbook = await archive.xml('xl/workbook.xml');
+    const relationships = await archive.relationships('xl/workbook.xml');
+    const parts = new Map();
+    for (const sheet of directChildren(firstDescendant(workbook, 'sheets') ?? workbook.documentElement, 'sheet')){
+        const name = attribute(sheet, 'name');
+        const relationship = relationships.get(attribute(sheet, 'r:id') ?? attribute(sheet, 'id') ?? '');
+        if (name && relationship?.type.endsWith('/worksheet')) parts.set(name, relationship.target);
+    }
+    return parts;
+}
+function drawingXml(media, charts, sheet) {
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        `<xdr:wsDr xmlns:xdr="${DRAWING_NAMESPACE}" xmlns:a="${work_xlsx_images_DRAWINGML_NAMESPACE}" xmlns:r="${work_xlsx_images_RELATIONSHIP_NAMESPACE}">`,
+        ...media.map(({ image, relationshipId, objectId })=>[
+                '<xdr:twoCellAnchor editAs="oneCell">',
+                xlsxTwoCellAnchorMarkers(image, sheet),
+                '<xdr:pic><xdr:nvPicPr>',
+                `<xdr:cNvPr id="${objectId}" name="${work_xlsx_images_escapeXml(image.name?.trim() || `Image ${objectId}`)}"${image.altText?.trim() ? ` descr="${work_xlsx_images_escapeXml(image.altText.trim())}"` : ''}/>`,
+                '<xdr:cNvPicPr><a:picLocks noChangeAspect="1"/></xdr:cNvPicPr></xdr:nvPicPr>',
+                `<xdr:blipFill><a:blip r:embed="${relationshipId}"/><a:stretch><a:fillRect/></a:stretch></xdr:blipFill>`,
+                '<xdr:spPr><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr>',
+                '</xdr:pic><xdr:clientData/></xdr:twoCellAnchor>'
+            ].join('')),
+        ...charts.map(({ chart, relationshipId, objectId })=>xlsxChartGraphicFrameXml(chart, relationshipId, objectId, sheet)),
+        '</xdr:wsDr>'
+    ].join('');
+}
+function drawingRelationshipsXml(media, charts) {
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        `<Relationships xmlns="${PACKAGE_RELATIONSHIP_NAMESPACE}">`,
+        ...media.map(({ path, relationshipId })=>`<Relationship Id="${relationshipId}" Type="${IMAGE_RELATIONSHIP}" Target="../media/${path.split('/').at(-1)}"/>`),
+        ...charts.map(({ path, relationshipId })=>`<Relationship Id="${relationshipId}" Type="${XLSX_CHART_RELATIONSHIP}" Target="../charts/${path.split('/').at(-1)}"/>`),
+        '</Relationships>'
+    ].join('');
+}
+async function bindDrawingToWorksheet(zip, worksheetPart, worksheetEntry, drawingPath) {
+    const worksheet = parseXml(await worksheetEntry.async('text'), worksheetPart);
+    for (const existing of directChildren(worksheet.documentElement, 'drawing'))existing.remove();
+    const relationshipPath = relationshipsPartPath(worksheetPart);
+    const relationshipEntry = zip.file(relationshipPath);
+    const relationships = relationshipEntry ? parseXml(await relationshipEntry.async('text'), relationshipPath) : parseXml(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${PACKAGE_RELATIONSHIP_NAMESPACE}"/>`, relationshipPath);
+    for (const existing of directChildren(relationships.documentElement, 'Relationship'))if (attribute(existing, 'Type')?.endsWith('/drawing')) existing.remove();
+    const relationshipId = nextRelationshipId(relationships);
+    const relationship = relationships.createElementNS(PACKAGE_RELATIONSHIP_NAMESPACE, 'Relationship');
+    relationship.setAttribute('Id', relationshipId);
+    relationship.setAttribute('Type', DRAWING_RELATIONSHIP);
+    relationship.setAttribute('Target', relativePartTarget(worksheetPart, drawingPath));
+    relationships.documentElement.append(relationship);
+    const drawing = worksheet.createElementNS(worksheet.documentElement.namespaceURI, 'drawing');
+    drawing.setAttributeNS(work_xlsx_images_RELATIONSHIP_NAMESPACE, 'r:id', relationshipId);
+    const insertionPoint = directChildren(worksheet.documentElement).find((element)=>[
+            'legacyDrawing',
+            'legacyDrawingHF',
+            'picture',
+            'oleObjects',
+            'controls',
+            'webPublishItems',
+            'tableParts',
+            'extLst'
+        ].includes(element.localName));
+    worksheet.documentElement.insertBefore(drawing, insertionPoint ?? null);
+    zip.file(worksheetPart, new XMLSerializer().serializeToString(worksheet));
+    zip.file(relationshipPath, new XMLSerializer().serializeToString(relationships));
+}
+function nextRelationshipId(document) {
+    const ids = new Set(directChildren(document.documentElement, 'Relationship').map((relationship)=>attribute(relationship, 'Id')).filter((id)=>Boolean(id)));
+    let index = 1;
+    while(ids.has(`rId${index}`))index += 1;
+    return `rId${index}`;
+}
+async function updateContentTypes(zip, drawingPaths, chartPaths, imageTypes) {
+    const entry = zip.file('[Content_Types].xml');
+    if (!entry) return;
+    const document = parseXml(await entry.async('text'), '[Content_Types].xml');
+    const namespace = document.documentElement.namespaceURI;
+    for (const [extension, contentType] of imageTypes){
+        const existing = directChildren(document.documentElement, 'Default').find((element)=>attribute(element, 'Extension')?.toLowerCase() === extension);
+        if (existing) {
+            existing.setAttribute('ContentType', contentType);
+            continue;
+        }
+        const definition = document.createElementNS(namespace, 'Default');
+        definition.setAttribute('Extension', extension);
+        definition.setAttribute('ContentType', contentType);
+        document.documentElement.append(definition);
+    }
+    for (const path of drawingPaths){
+        const partName = `/${path}`;
+        const existing = directChildren(document.documentElement, 'Override').find((element)=>attribute(element, 'PartName') === partName);
+        const override = existing ?? document.createElementNS(namespace, 'Override');
+        override.setAttribute('PartName', partName);
+        override.setAttribute('ContentType', DRAWING_CONTENT_TYPE);
+        if (!existing) document.documentElement.append(override);
+    }
+    for (const path of chartPaths){
+        const partName = `/${path}`;
+        const existing = directChildren(document.documentElement, 'Override').find((element)=>attribute(element, 'PartName') === partName);
+        const override = existing ?? document.createElementNS(namespace, 'Override');
+        override.setAttribute('PartName', partName);
+        override.setAttribute('ContentType', XLSX_CHART_CONTENT_TYPE);
+        if (!existing) document.documentElement.append(override);
+    }
+    zip.file('[Content_Types].xml', new XMLSerializer().serializeToString(document));
+}
+function relationshipsPartPath(sourcePart) {
+    const segments = sourcePart.split('/');
+    const name = segments.pop() ?? '';
+    return [
+        ...segments,
+        '_rels',
+        `${name}.rels`
+    ].join('/');
+}
+function relativePartTarget(sourcePart, targetPart) {
+    const source = sourcePart.split('/').slice(0, -1);
+    const target = targetPart.split('/');
+    while(source.length && target.length && source[0] === target[0]){
+        source.shift();
+        target.shift();
+    }
+    return [
+        ...source.map(()=>'..'),
+        ...target
+    ].join('/');
+}
+function work_xlsx_images_partNumber(path) {
+    return /(\d+)(?:\.xml)?$/i.exec(path)?.[1] ?? '1';
+}
+function work_xlsx_images_escapeXml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+}
+const OOXML_TO_FRIENDLY_TOKEN = {
+    P: '{page}',
+    N: '{pages}',
+    A: '{sheet}',
+    F: '{file}',
+    Z: '{path}',
+    D: '{date}',
+    T: '{time}'
+};
+const FRIENDLY_TO_OOXML_TOKEN = Object.fromEntries(Object.entries(OOXML_TO_FRIENDLY_TOKEN).map(([ooxml, friendly])=>[
+        friendly,
+        `&${ooxml}`
+    ]));
+const RICH_FORMAT_CODES = new Set([
+    'B',
+    'I',
+    'U',
+    'E',
+    'S',
+    'X',
+    'Y',
+    'O',
+    'H',
+    '+',
+    '-'
+]);
+function parseXlsxHeaderFooterSections(source) {
+    if (!source) return;
+    const sections = {
+        left: '',
+        center: '',
+        right: ''
+    };
+    let section = 'center';
+    for(let index = 0; index < source.length; index += 1){
+        if ('&' !== source[index] || index === source.length - 1) {
+            sections[section] += source[index];
+            continue;
+        }
+        const code = source[index + 1];
+        if ('&' === code) {
+            sections[section] += '&';
+            index += 1;
+            continue;
+        }
+        if ('L' === code || 'C' === code || 'R' === code) {
+            section = 'L' === code ? 'left' : 'C' === code ? 'center' : 'right';
+            index += 1;
+            continue;
+        }
+        const friendlyToken = OOXML_TO_FRIENDLY_TOKEN[code];
+        if (friendlyToken) {
+            sections[section] += friendlyToken;
+            index += 1;
+            continue;
+        }
+        const formattingEnd = formattingCodeEnd(source, index);
+        if (null !== formattingEnd || 'G' === code) {
+            index = formattingEnd ?? index + 1;
+            continue;
+        }
+        sections[section] += `&${code}`;
+        index += 1;
+    }
+    return Object.values(sections).some(Boolean) ? sections : void 0;
+}
+function serializeXlsxHeaderFooterSections(sections) {
+    if (!sections) return '';
+    return [
+        [
+            'L',
+            sections.left
+        ],
+        [
+            'C',
+            sections.center
+        ],
+        [
+            'R',
+            sections.right
+        ]
+    ].flatMap(([code, template])=>template ? [
+            `&${code}${serializeTemplate(template)}`
+        ] : []).join('');
+}
+function readXlsxHeaderFooter(element) {
+    if (!element) return {};
+    const settings = {};
+    const header = parseXlsxHeaderFooterSections(directChild(element, 'oddHeader')?.textContent);
+    const footer = parseXlsxHeaderFooterSections(directChild(element, 'oddFooter')?.textContent);
+    if (header) settings.header = header;
+    if (footer) settings.footer = footer;
+    if (null !== attribute(element, 'scaleWithDoc')) settings.scaleWithDocument = work_xlsx_header_footer_booleanAttribute(element, 'scaleWithDoc');
+    if (null !== attribute(element, 'alignWithMargins')) settings.alignWithMargins = work_xlsx_header_footer_booleanAttribute(element, 'alignWithMargins');
+    return settings;
+}
+function writeXlsxHeaderFooter(document, pageSetup) {
+    const header = serializeXlsxHeaderFooterSections(pageSetup.header);
+    const footer = serializeXlsxHeaderFooterSections(pageSetup.footer);
+    if (!header && !footer && void 0 === pageSetup.scaleWithDocument && void 0 === pageSetup.alignWithMargins) return null;
+    const element = document.createElementNS(document.documentElement.namespaceURI, 'headerFooter');
+    if (void 0 !== pageSetup.scaleWithDocument) element.setAttribute('scaleWithDoc', pageSetup.scaleWithDocument ? '1' : '0');
+    if (void 0 !== pageSetup.alignWithMargins) element.setAttribute('alignWithMargins', pageSetup.alignWithMargins ? '1' : '0');
+    appendTextChild(document, element, 'oddHeader', header);
+    appendTextChild(document, element, 'oddFooter', footer);
+    return element;
+}
+function inspectXlsxHeaderFooterText(source) {
+    const inspection = {
+        hasFormatting: false,
+        hasImage: false
+    };
+    if (!source) return inspection;
+    for(let index = 0; index < source.length - 1; index += 1){
+        if ('&' !== source[index]) continue;
+        const code = source[index + 1];
+        if ('&' === code) {
+            index += 1;
+            continue;
+        }
+        if ('G' === code) inspection.hasImage = true;
+        if (null !== formattingCodeEnd(source, index)) inspection.hasFormatting = true;
+    }
+    return inspection;
+}
+function serializeTemplate(template) {
+    const escaped = template.replaceAll('&', '&&');
+    return escaped.replace(/\{(?:page|pages|sheet|file|path|date|time)\}/g, (token)=>FRIENDLY_TO_OOXML_TOKEN[token] ?? token);
+}
+function formattingCodeEnd(source, ampersandIndex) {
+    const code = source[ampersandIndex + 1];
+    if (RICH_FORMAT_CODES.has(code)) return ampersandIndex + 1;
+    if (/^\d$/.test(code)) {
+        let end = ampersandIndex + 1;
+        while(end + 1 < source.length && /^\d$/.test(source[end + 1]))end += 1;
+        return end;
+    }
+    if ('"' === code) {
+        const closingQuote = source.indexOf('"', ampersandIndex + 2);
+        return closingQuote < 0 ? source.length - 1 : closingQuote;
+    }
+    if ('K' === code) {
+        let end = ampersandIndex + 1;
+        while(end + 1 < source.length && end < ampersandIndex + 7 && /^[0-9A-Fa-f+-]$/.test(source[end + 1]))end += 1;
+        return end;
+    }
+    return null;
+}
+function appendTextChild(document, parent, name, value) {
+    if (!value) return;
+    const child = document.createElementNS(document.documentElement.namespaceURI, name);
+    child.textContent = value;
+    parent.append(child);
+}
+function work_xlsx_header_footer_booleanAttribute(element, name) {
+    const value = attribute(element, name)?.toLowerCase();
+    return '1' === value || 'true' === value;
+}
+const PAPER_SIZE_CODES = {
+    letter: '1',
+    tabloid: '3',
+    legal: '5',
+    a3: '8',
+    a4: '9',
+    a5: '11'
+};
+const PAPER_SIZES_BY_CODE = new Map(Object.entries(PAPER_SIZE_CODES).map(([paperSize, code])=>[
+        code,
+        paperSize
+    ]));
+function readXlsxPageSetup(document) {
+    const root = document.documentElement;
+    const pageSetupElement = directChild(root, 'pageSetup');
+    const marginsElement = directChild(root, 'pageMargins');
+    const printOptions = directChild(root, 'printOptions');
+    const headerFooterElement = directChild(root, 'headerFooter');
+    const sheetProperties = directChild(root, 'sheetPr');
+    const setupProperties = sheetProperties ? directChild(sheetProperties, 'pageSetUpPr') : void 0;
+    if (!pageSetupElement && !marginsElement && !printOptions && !setupProperties && !headerFooterElement) return;
+    const pageSetup = {};
+    const paperSize = pageSetupElement ? attribute(pageSetupElement, 'paperSize') : null;
+    const editablePaperSize = paperSize ? PAPER_SIZES_BY_CODE.get(paperSize) : void 0;
+    if (editablePaperSize) pageSetup.paperSize = editablePaperSize;
+    const orientation = pageSetupElement ? attribute(pageSetupElement, 'orientation')?.toLowerCase() : void 0;
+    if ('portrait' === orientation || 'landscape' === orientation) pageSetup.orientation = orientation;
+    const scale = boundedIntegerAttribute(pageSetupElement, 'scale', 10, 400);
+    if (void 0 !== scale) pageSetup.scale = scale;
+    const fitToWidth = boundedIntegerAttribute(pageSetupElement, 'fitToWidth', 0, 32767);
+    if (void 0 !== fitToWidth) pageSetup.fitToWidth = fitToWidth;
+    const fitToHeight = boundedIntegerAttribute(pageSetupElement, 'fitToHeight', 0, 32767);
+    if (void 0 !== fitToHeight) pageSetup.fitToHeight = fitToHeight;
+    const pageOrder = pageSetupElement ? attribute(pageSetupElement, 'pageOrder') : null;
+    if ('downThenOver' === pageOrder || 'overThenDown' === pageOrder) pageSetup.pageOrder = pageOrder;
+    const pageNumberStart = boundedIntegerAttribute(pageSetupElement, 'firstPageNumber', 1, 32767);
+    const useFirstPageNumber = pageSetupElement ? attribute(pageSetupElement, 'useFirstPageNumber') : null;
+    if (void 0 !== pageNumberStart && (null === useFirstPageNumber || work_xlsx_page_setup_booleanAttribute(pageSetupElement, 'useFirstPageNumber'))) pageSetup.pageNumberStart = pageNumberStart;
+    if (setupProperties && null !== attribute(setupProperties, 'fitToPage')) pageSetup.fitToPage = work_xlsx_page_setup_booleanAttribute(setupProperties, 'fitToPage');
+    if (printOptions && null !== attribute(printOptions, 'horizontalCentered')) pageSetup.horizontalCentered = work_xlsx_page_setup_booleanAttribute(printOptions, 'horizontalCentered');
+    if (printOptions && null !== attribute(printOptions, 'verticalCentered')) pageSetup.verticalCentered = work_xlsx_page_setup_booleanAttribute(printOptions, 'verticalCentered');
+    const margins = readMargins(marginsElement);
+    if (margins) pageSetup.margins = margins;
+    Object.assign(pageSetup, readXlsxHeaderFooter(headerFooterElement));
+    return pageSetup;
+}
+function writeXlsxPageSetup(document, pageSetup) {
+    const root = document.documentElement;
+    for (const existing of directChildren(root).filter((element)=>[
+            'printOptions',
+            'pageMargins',
+            'pageSetup',
+            'headerFooter'
+        ].includes(element.localName)))existing.remove();
+    writeFitToPage(document, pageSetup?.fitToPage);
+    if (!pageSetup) return;
+    const elements = [];
+    if (void 0 !== pageSetup.horizontalCentered || void 0 !== pageSetup.verticalCentered) {
+        const printOptions = document.createElementNS(root.namespaceURI, 'printOptions');
+        if (void 0 !== pageSetup.horizontalCentered) printOptions.setAttribute('horizontalCentered', pageSetup.horizontalCentered ? '1' : '0');
+        if (void 0 !== pageSetup.verticalCentered) printOptions.setAttribute('verticalCentered', pageSetup.verticalCentered ? '1' : '0');
+        elements.push(printOptions);
+    }
+    if (pageSetup.margins) elements.push(writeMargins(document, pageSetup.margins));
+    const setup = document.createElementNS(root.namespaceURI, 'pageSetup');
+    if (pageSetup.paperSize) setup.setAttribute('paperSize', PAPER_SIZE_CODES[normalizeSpreadsheetPaperSize(pageSetup.paperSize)]);
+    if (pageSetup.orientation) setup.setAttribute('orientation', pageSetup.orientation);
+    if (void 0 !== pageSetup.scale) setup.setAttribute('scale', String(pageSetup.scale));
+    if (void 0 !== pageSetup.fitToWidth) setup.setAttribute('fitToWidth', String(pageSetup.fitToWidth));
+    if (void 0 !== pageSetup.fitToHeight) setup.setAttribute('fitToHeight', String(pageSetup.fitToHeight));
+    if (pageSetup.pageOrder) setup.setAttribute('pageOrder', pageSetup.pageOrder);
+    if (void 0 !== pageSetup.pageNumberStart && Number.isInteger(pageSetup.pageNumberStart) && pageSetup.pageNumberStart >= 1 && pageSetup.pageNumberStart <= 32767) {
+        setup.setAttribute('firstPageNumber', String(pageSetup.pageNumberStart));
+        setup.setAttribute('useFirstPageNumber', '1');
+    }
+    if (setup.attributes.length) elements.push(setup);
+    const headerFooter = writeXlsxHeaderFooter(document, pageSetup);
+    if (headerFooter) elements.push(headerFooter);
+    const anchor = directChildren(root).find((element)=>[
+            'rowBreaks',
+            'colBreaks',
+            'customProperties',
+            'cellWatches',
+            'ignoredErrors',
+            'smartTags',
+            'drawing',
+            'legacyDrawing',
+            'legacyDrawingHF',
+            'picture',
+            'oleObjects',
+            'controls',
+            'webPublishItems',
+            'tableParts',
+            'extLst'
+        ].includes(element.localName)) ?? null;
+    for (const element of elements)root.insertBefore(element, anchor);
+}
+function isEditableXlsxPaperSizeCode(value) {
+    return PAPER_SIZES_BY_CODE.has(value);
+}
+function writeFitToPage(document, fitToPage) {
+    const root = document.documentElement;
+    let sheetProperties = directChild(root, 'sheetPr');
+    let setupProperties = sheetProperties ? directChild(sheetProperties, 'pageSetUpPr') : void 0;
+    if (void 0 !== fitToPage) {
+        if (!sheetProperties) {
+            sheetProperties = document.createElementNS(root.namespaceURI, 'sheetPr');
+            root.insertBefore(sheetProperties, root.firstElementChild);
+        }
+        if (!setupProperties) {
+            setupProperties = document.createElementNS(root.namespaceURI, 'pageSetUpPr');
+            sheetProperties.append(setupProperties);
+        }
+        setupProperties.setAttribute('fitToPage', fitToPage ? '1' : '0');
+        return;
+    }
+    setupProperties?.removeAttribute('fitToPage');
+    if (setupProperties && !setupProperties.attributes.length && !setupProperties.children.length) setupProperties.remove();
+}
+function readMargins(element) {
+    if (!element) return null;
+    const values = [
+        'top',
+        'right',
+        'bottom',
+        'left',
+        'header',
+        'footer'
+    ].map((name)=>nonnegativeNumberAttribute(element, name));
+    if (values.some((value)=>null === value)) return null;
+    const [top, right, bottom, left, header, footer] = values;
+    return {
+        top: inchesToMillimeters(top),
+        right: inchesToMillimeters(right),
+        bottom: inchesToMillimeters(bottom),
+        left: inchesToMillimeters(left),
+        header: inchesToMillimeters(header),
+        footer: inchesToMillimeters(footer)
+    };
+}
+function writeMargins(document, margins) {
+    const element = document.createElementNS(document.documentElement.namespaceURI, 'pageMargins');
+    for (const [name, value] of Object.entries({
+        left: margins.left,
+        right: margins.right,
+        top: margins.top,
+        bottom: margins.bottom,
+        header: margins.header,
+        footer: margins.footer
+    }))element.setAttribute(name, millimetersToInches(value));
+    return element;
+}
+function boundedIntegerAttribute(element, name, minimum, maximum) {
+    if (!element) return;
+    const source = attribute(element, name);
+    if (null === source) return;
+    const value = Number(source);
+    return Number.isInteger(value) && value >= minimum && value <= maximum ? value : void 0;
+}
+function nonnegativeNumberAttribute(element, name) {
+    const source = attribute(element, name);
+    if (null === source) return null;
+    const value = Number(source);
+    return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function work_xlsx_page_setup_booleanAttribute(element, name) {
+    const value = element ? attribute(element, name)?.toLowerCase() : void 0;
+    return '1' === value || 'true' === value;
+}
+function inchesToMillimeters(value) {
+    return Number((25.4 * value).toFixed(4));
+}
+function millimetersToInches(value) {
+    return String(Number((value / 25.4).toFixed(4)));
+}
+function readXlsxProtection(worksheet, styles) {
+    const protectedRanges = readProtectedRanges(worksheet);
+    const protection = directChild(worksheet.documentElement, 'sheetProtection');
+    const authority = protection || protectedRanges.length ? {
+        ...authorityFromElement(protection),
+        allowRangeList: protectedRanges
+    } : void 0;
+    return {
+        authority,
+        cellProtectionRanges: readCellProtectionRanges(worksheet, styles)
+    };
+}
+function writeXlsxProtection(worksheet, sheet, styles) {
+    const root = worksheet.documentElement;
+    for (const element of directChildren(root, 'sheetProtection'))element.remove();
+    for (const element of directChildren(root, 'protectedRanges'))element.remove();
+    const authority = normalizeSheetProtectionAuthority(sheet.config?.authority);
+    if (1 === authority.sheet) {
+        const element = worksheet.createElementNS(root.namespaceURI, 'sheetProtection');
+        copyAttributes(element, authority.xlsxAttributes);
+        writeProtectionAttributes(element, authority);
+        insertWorksheetFeature(root, element, [
+            'protectedRanges',
+            'scenarios',
+            'autoFilter',
+            'sortState',
+            'dataConsolidate',
+            'customSheetViews',
+            'mergeCells',
+            'phoneticPr',
+            'conditionalFormatting',
+            'dataValidations',
+            'hyperlinks',
+            'printOptions',
+            'pageMargins',
+            'pageSetup',
+            'headerFooter',
+            'drawing',
+            'legacyDrawing',
+            'ignoredErrors',
+            'extLst'
+        ]);
+    }
+    writeProtectedRanges(worksheet, [
+        ...authority.allowRangeList,
+        ...generatedEditableProtectionRanges(authority)
+    ]);
+    if (styles) writeCellProtectionStyles(worksheet, sheet, styles);
+}
+class XlsxCellProtectionWriter {
+    styles;
+    cellXfs;
+    generated = new Map();
+    changed = false;
+    constructor(styles){
+        this.styles = styles;
+        const root = styles.documentElement;
+        this.cellXfs = directChild(root, 'cellXfs') ?? styles.createElementNS(root.namespaceURI, 'cellXfs');
+        if (!this.cellXfs.parentElement) {
+            const anchor = directChildren(root).find((child)=>[
+                    'cellStyles',
+                    'dxfs',
+                    'tableStyles',
+                    'colors',
+                    'extLst'
+                ].includes(child.localName));
+            root.insertBefore(this.cellXfs, anchor ?? null);
+        }
+        if (!directChildren(this.cellXfs, 'xf').length) {
+            const base = styles.createElementNS(root.namespaceURI, 'xf');
+            base.setAttribute('numFmtId', '0');
+            base.setAttribute('fontId', '0');
+            base.setAttribute('fillId', '0');
+            base.setAttribute('borderId', '0');
+            base.setAttribute('xfId', '0');
+            this.cellXfs.append(base);
+            this.changed = true;
+        }
+        this.updateCount();
+    }
+    styleId(baseStyleId, locked, hidden) {
+        const styles = directChildren(this.cellXfs, 'xf');
+        const baseIndex = Number.isInteger(baseStyleId) && styles[baseStyleId] ? baseStyleId : 0;
+        if (sameProtection(readProtectionStyle(styles[baseIndex]), {
+            locked,
+            hidden
+        })) return baseIndex;
+        const key = `${baseIndex}:${locked ? 1 : 0}:${hidden ? 1 : 0}`;
+        const cached = this.generated.get(key);
+        if (void 0 !== cached) return cached;
+        const clone = styles[baseIndex].cloneNode(true);
+        for (const element of directChildren(clone, 'protection'))element.remove();
+        clone.setAttribute('applyProtection', '1');
+        const protection = this.styles.createElementNS(this.styles.documentElement.namespaceURI, 'protection');
+        protection.setAttribute('locked', locked ? '1' : '0');
+        protection.setAttribute('hidden', hidden ? '1' : '0');
+        clone.insertBefore(protection, directChild(clone, 'extLst') ?? null);
+        const index = styles.length;
+        this.cellXfs.append(clone);
+        this.generated.set(key, index);
+        this.changed = true;
+        this.updateCount();
+        return index;
+    }
+    serialize() {
+        return new XMLSerializer().serializeToString(this.styles);
+    }
+    updateCount() {
+        this.cellXfs.setAttribute('count', String(directChildren(this.cellXfs, 'xf').length));
+    }
+}
+function diagnoseXlsxProtection(worksheet, styles) {
+    const protection = directChild(worksheet.documentElement, 'sheetProtection');
+    const protectedRanges = readProtectedRanges(worksheet);
+    if (!protection && !protectedRanges.length) return [];
+    const diagnostics = [
+        {
+            code: 'xlsx.protection',
+            message: 'Sheet lock state, locked and unlocked cells, selection rules, and passwordless editable ranges are preserved and enforced.',
+            severity: 'info'
+        }
+    ];
+    const sourceAttributes = protection ? work_xlsx_protection_attributes(protection) : {};
+    if (hasCredentialAttributes(sourceAttributes)) diagnostics.push({
+        code: 'xlsx.protection.password',
+        message: 'The source password verifier is preserved, but Work cannot authenticate it; locked cells remain protected.',
+        severity: 'warning'
+    });
+    if (protectedRanges.some(editableRangeRequiresCredentials)) diagnostics.push({
+        code: 'xlsx.protection.range-credentials',
+        message: 'Password- or permission-backed editable ranges are preserved but remain locked because Work cannot authenticate their credentials.',
+        severity: 'warning'
+    });
+    if (protection) diagnostics.push({
+        code: 'xlsx.protection.permissions',
+        message: 'Action-specific protection permissions are preserved; Work enforces cell editing and selection but not every Excel row, column, object, filter, or pivot permission.',
+        severity: 'warning'
+    });
+    if (hasHiddenFormula(worksheet, styles)) diagnostics.push({
+        code: 'xlsx.protection.hidden-formulas',
+        message: 'Formula-hidden protection is preserved for XLSX export, but formulas can still appear in the Work formula bar.',
+        severity: 'warning'
+    });
+    return diagnostics;
+}
+function authorityFromElement(element) {
+    const defaults = normalizeSheetProtectionAuthority(void 0);
+    if (!element) return defaults;
+    const source = work_xlsx_protection_attributes(element);
+    return {
+        ...defaults,
+        sheet: work_xlsx_protection_booleanAttribute(element, 'sheet', false) ? 1 : 0,
+        selectLockedCells: work_xlsx_protection_booleanAttribute(element, 'selectLockedCells', false) ? 0 : 1,
+        selectunLockedCells: work_xlsx_protection_booleanAttribute(element, 'selectUnlockedCells', false) ? 0 : 1,
+        formatCells: work_xlsx_protection_booleanAttribute(element, 'formatCells', true) ? 0 : 1,
+        formatColumns: work_xlsx_protection_booleanAttribute(element, 'formatColumns', true) ? 0 : 1,
+        formatRows: work_xlsx_protection_booleanAttribute(element, 'formatRows', true) ? 0 : 1,
+        insertColumns: work_xlsx_protection_booleanAttribute(element, 'insertColumns', true) ? 0 : 1,
+        insertRows: work_xlsx_protection_booleanAttribute(element, 'insertRows', true) ? 0 : 1,
+        insertHyperlinks: work_xlsx_protection_booleanAttribute(element, 'insertHyperlinks', true) ? 0 : 1,
+        deleteColumns: work_xlsx_protection_booleanAttribute(element, 'deleteColumns', true) ? 0 : 1,
+        deleteRows: work_xlsx_protection_booleanAttribute(element, 'deleteRows', true) ? 0 : 1,
+        sort: work_xlsx_protection_booleanAttribute(element, 'sort', true) ? 0 : 1,
+        filter: work_xlsx_protection_booleanAttribute(element, 'autoFilter', true) ? 0 : 1,
+        usePivotTablereports: work_xlsx_protection_booleanAttribute(element, 'pivotTables', true) ? 0 : 1,
+        editObjects: work_xlsx_protection_booleanAttribute(element, 'objects', false) ? 0 : 1,
+        editScenarios: work_xlsx_protection_booleanAttribute(element, 'scenarios', false) ? 0 : 1,
+        defaultSheetHintText: DEFAULT_PROTECTION_HINT,
+        xlsxAttributes: Object.keys(source).length ? source : void 0
+    };
+}
+function readProtectedRanges(worksheet) {
+    const container = directChild(worksheet.documentElement, 'protectedRanges');
+    if (!container) return [];
+    return directChildren(container, 'protectedRange').flatMap((element, index)=>{
+        const ranges = parseSqref(attribute(element, 'sqref'));
+        if (!ranges.length) return [];
+        return [
+            {
+                name: attribute(element, 'name')?.trim() || `Range ${index + 1}`,
+                sqref: formatSpreadsheetCellRanges(ranges),
+                xlsxAttributes: work_xlsx_protection_attributes(element)
+            }
+        ];
+    });
+}
+function readCellProtectionRanges(worksheet, styles) {
+    const xfs = styles ? directChildren(firstDescendant(styles, 'cellXfs') ?? styles.documentElement, 'xf') : [];
+    if (!xfs.length) return [];
+    const styleList = xfs.map(readProtectionStyle);
+    const bounds = worksheetBounds(worksheet);
+    const ranges = [];
+    if (!sameProtection(styleList[0], {
+        locked: true,
+        hidden: false
+    })) ranges.push({
+        range: bounds,
+        ...styleList[0]
+    });
+    for (const column of descendants(worksheet, 'col')){
+        const style = indexedStyle(styleList, attribute(column, 'style'));
+        const minimum = work_xlsx_protection_positiveInteger(attribute(column, 'min'));
+        const maximum = work_xlsx_protection_positiveInteger(attribute(column, 'max'));
+        if (style && null !== minimum && null !== maximum) ranges.push({
+            range: {
+                row: [
+                    ...bounds.row
+                ],
+                column: [
+                    minimum - 1,
+                    maximum - 1
+                ]
+            },
+            ...style
+        });
+    }
+    for (const row of descendants(worksheet, 'row')){
+        const style = indexedStyle(styleList, attribute(row, 's'));
+        const rowNumber = work_xlsx_protection_positiveInteger(attribute(row, 'r'));
+        if (style && null !== rowNumber) ranges.push({
+            range: {
+                row: [
+                    rowNumber - 1,
+                    rowNumber - 1
+                ],
+                column: [
+                    ...bounds.column
+                ]
+            },
+            ...style
+        });
+    }
+    for (const cell of descendants(worksheet, 'c')){
+        const style = indexedStyle(styleList, attribute(cell, 's'));
+        const coordinate = parseCellReference(attribute(cell, 'r'));
+        if (style && coordinate) ranges.push({
+            range: {
+                row: [
+                    coordinate.row,
+                    coordinate.row
+                ],
+                column: [
+                    coordinate.column,
+                    coordinate.column
+                ]
+            },
+            ...style
+        });
+    }
+    return ranges;
+}
+function writeProtectionAttributes(element, authority) {
+    element.setAttribute('sheet', '1');
+    element.setAttribute('selectLockedCells', authority.selectLockedCells ? '0' : '1');
+    element.setAttribute('selectUnlockedCells', authority.selectunLockedCells ? '0' : '1');
+    const mappings = [
+        [
+            'formatCells',
+            'formatCells'
+        ],
+        [
+            'formatColumns',
+            'formatColumns'
+        ],
+        [
+            'formatRows',
+            'formatRows'
+        ],
+        [
+            'insertColumns',
+            'insertColumns'
+        ],
+        [
+            'insertRows',
+            'insertRows'
+        ],
+        [
+            'insertHyperlinks',
+            'insertHyperlinks'
+        ],
+        [
+            'deleteColumns',
+            'deleteColumns'
+        ],
+        [
+            'deleteRows',
+            'deleteRows'
+        ],
+        [
+            'sort',
+            'sort'
+        ],
+        [
+            'filter',
+            'autoFilter'
+        ],
+        [
+            'usePivotTablereports',
+            'pivotTables'
+        ],
+        [
+            'editObjects',
+            'objects'
+        ],
+        [
+            'editScenarios',
+            'scenarios'
+        ]
+    ];
+    for (const [key, name] of mappings)element.setAttribute(name, authority[key] ? '0' : '1');
+}
+function writeProtectedRanges(document, ranges) {
+    const root = document.documentElement;
+    const container = document.createElementNS(root.namespaceURI, 'protectedRanges');
+    const written = new Set();
+    for (const range of ranges){
+        const parsed = parseSpreadsheetCellRanges(range.sqref);
+        if (!range.name.trim() || !parsed?.length) continue;
+        const reference = formatSpreadsheetCellRanges(parsed).replaceAll(',', ' ');
+        if (written.has(reference)) continue;
+        written.add(reference);
+        const element = document.createElementNS(root.namespaceURI, 'protectedRange');
+        copyAttributes(element, range.xlsxAttributes);
+        element.setAttribute('name', range.name.trim());
+        element.setAttribute('sqref', reference);
+        container.append(element);
+    }
+    if (!container.children.length) return;
+    insertWorksheetFeature(root, container, [
+        'scenarios',
+        'autoFilter',
+        'sortState',
+        'dataConsolidate',
+        'customSheetViews',
+        'mergeCells',
+        'phoneticPr',
+        'conditionalFormatting',
+        'dataValidations',
+        'hyperlinks',
+        'printOptions',
+        'pageMargins',
+        'pageSetup',
+        'headerFooter',
+        'drawing',
+        'legacyDrawing',
+        'ignoredErrors',
+        'extLst'
+    ]);
+}
+function writeCellProtectionStyles(worksheet, sheet, styles) {
+    const authority = normalizeSheetProtectionAuthority(sheet.config?.authority);
+    for (const [row, values] of sparseArrayEntries(sheet.data))for (const [column, source] of sparseArrayEntries(values)){
+        const cell = source;
+        if (!cell) continue;
+        const compact = compactProtectionAt(authority, row, column);
+        if (void 0 === cell.lo && void 0 === cell.hi && void 0 === compact) continue;
+        const element = ensureCellElement(worksheet, row, column);
+        const baseStyle = nonNegativeInteger(attribute(element, 's')) ?? 0;
+        const styleId = styles.styleId(baseStyle, void 0 === cell.lo ? compact?.locked ?? true : 0 !== cell.lo, void 0 === cell.hi ? compact?.hidden ?? false : 1 === cell.hi);
+        if (styleId) element.setAttribute('s', String(styleId));
+        else element.removeAttribute('s');
+    }
+}
+function generatedEditableProtectionRanges(authority) {
+    let editable = [];
+    for (const item of authority.cellProtectionRanges)if (item.locked) editable = editable.flatMap((range)=>subtractSpreadsheetRange(range, item.range));
+    else editable.push(item.range);
+    return editable.map((range, index)=>({
+            name: `Work editable range ${index + 1}`,
+            sqref: formatSpreadsheetCellRanges([
+                range
+            ])
+        }));
+}
+function compactProtectionAt(authority, row, column) {
+    for(let index = authority.cellProtectionRanges.length - 1; index >= 0; index -= 1){
+        const item = authority.cellProtectionRanges[index];
+        if (row >= item.range.row[0] && row <= item.range.row[1] && column >= item.range.column[0] && column <= item.range.column[1]) return {
+            locked: item.locked,
+            hidden: item.hidden
+        };
+    }
+}
+function subtractSpreadsheetRange(source, removed) {
+    const top = Math.max(source.row[0], removed.row[0]);
+    const bottom = Math.min(source.row[1], removed.row[1]);
+    const left = Math.max(source.column[0], removed.column[0]);
+    const right = Math.min(source.column[1], removed.column[1]);
+    if (top > bottom || left > right) return [
+        source
+    ];
+    const remaining = [];
+    if (source.row[0] < top) remaining.push({
+        row: [
+            source.row[0],
+            top - 1
+        ],
+        column: [
+            ...source.column
+        ]
+    });
+    if (bottom < source.row[1]) remaining.push({
+        row: [
+            bottom + 1,
+            source.row[1]
+        ],
+        column: [
+            ...source.column
+        ]
+    });
+    if (source.column[0] < left) remaining.push({
+        row: [
+            top,
+            bottom
+        ],
+        column: [
+            source.column[0],
+            left - 1
+        ]
+    });
+    if (right < source.column[1]) remaining.push({
+        row: [
+            top,
+            bottom
+        ],
+        column: [
+            right + 1,
+            source.column[1]
+        ]
+    });
+    return remaining;
+}
+function ensureCellElement(document, rowIndex, columnIndex) {
+    const sheetData = directChild(document.documentElement, 'sheetData');
+    if (!sheetData) throw new Error('XLSX worksheet does not contain sheetData');
+    const rowNumber = rowIndex + 1;
+    let row = directChildren(sheetData, 'row').find((element)=>attribute(element, 'r') === String(rowNumber));
+    if (!row) {
+        row = document.createElementNS(document.documentElement.namespaceURI, 'row');
+        row.setAttribute('r', String(rowNumber));
+        const anchor = directChildren(sheetData, 'row').find((element)=>(work_xlsx_protection_positiveInteger(attribute(element, 'r')) ?? Number.MAX_SAFE_INTEGER) > rowNumber);
+        sheetData.insertBefore(row, anchor ?? null);
+    }
+    const reference = encodeCell(rowIndex, columnIndex);
+    let cell = directChildren(row, 'c').find((element)=>attribute(element, 'r') === reference);
+    if (!cell) {
+        cell = document.createElementNS(document.documentElement.namespaceURI, 'c');
+        cell.setAttribute('r', reference);
+        const anchor = directChildren(row, 'c').find((element)=>{
+            const coordinate = parseCellReference(attribute(element, 'r'));
+            return coordinate ? coordinate.column > columnIndex : false;
+        });
+        row.insertBefore(cell, anchor ?? null);
+        expandWorksheetDimension(document, rowIndex, columnIndex);
+    }
+    return cell;
+}
+function worksheetBounds(document) {
+    const reference = attribute(directChild(document.documentElement, 'dimension') ?? document.documentElement, 'ref');
+    const parsed = reference ? parseSpreadsheetCellRanges(reference)?.[0] : void 0;
+    if (parsed) return {
+        row: [
+            0,
+            parsed.row[1]
+        ],
+        column: [
+            0,
+            parsed.column[1]
+        ]
+    };
+    const coordinates = descendants(document, 'c').map((cell)=>parseCellReference(attribute(cell, 'r'))).filter((value)=>Boolean(value));
+    return {
+        row: [
+            0,
+            Math.max(0, ...coordinates.map((value)=>value.row))
+        ],
+        column: [
+            0,
+            Math.max(0, ...coordinates.map((value)=>value.column))
+        ]
+    };
+}
+function expandWorksheetDimension(document, row, column) {
+    const root = document.documentElement;
+    let dimension = directChild(root, 'dimension');
+    const bounds = worksheetBounds(document);
+    bounds.row[1] = Math.max(bounds.row[1], row);
+    bounds.column[1] = Math.max(bounds.column[1], column);
+    if (!dimension) {
+        dimension = document.createElementNS(root.namespaceURI, 'dimension');
+        root.insertBefore(dimension, directChildren(root)[0] ?? null);
+    }
+    dimension.setAttribute('ref', `${encodeCell(bounds.row[0], bounds.column[0])}:${encodeCell(bounds.row[1], bounds.column[1])}`);
+}
+function readProtectionStyle(xf) {
+    const protection = directChild(xf, 'protection');
+    if (!protection || false === work_xlsx_protection_booleanAttribute(xf, 'applyProtection', true)) return {
+        locked: true,
+        hidden: false
+    };
+    return {
+        locked: work_xlsx_protection_booleanAttribute(protection, 'locked', true),
+        hidden: work_xlsx_protection_booleanAttribute(protection, 'hidden', false)
+    };
+}
+function hasHiddenFormula(worksheet, styles) {
+    const formulas = descendants(worksheet, 'c').filter((cell)=>Boolean(directChild(cell, 'f')));
+    if (!formulas.length) return false;
+    const ranges = readCellProtectionRanges(worksheet, styles);
+    return formulas.some((cell)=>{
+        const coordinate = parseCellReference(attribute(cell, 'r'));
+        if (!coordinate) return false;
+        let hidden = false;
+        for (const item of ranges)if (coordinate.row >= item.range.row[0] && coordinate.row <= item.range.row[1] && coordinate.column >= item.range.column[0] && coordinate.column <= item.range.column[1]) hidden = item.hidden;
+        return hidden;
+    });
+}
+function insertWorksheetFeature(root, element, anchors) {
+    root.insertBefore(element, directChildren(root).find((child)=>anchors.includes(child.localName)) ?? null);
+}
+function parseSqref(value) {
+    return value ? parseSpreadsheetCellRanges(value.trim().replace(/\s+/g, ',')) ?? [] : [];
+}
+function indexedStyle(styles, value) {
+    const index = nonNegativeInteger(value);
+    return null === index ? null : styles[index] ?? null;
+}
+function parseCellReference(value) {
+    const match = /^\$?([A-Z]{1,3})\$?([1-9]\d*)$/i.exec(value ?? '');
+    if (!match) return null;
+    let column = 0;
+    for (const character of match[1].toUpperCase())column = 26 * column + character.charCodeAt(0) - 64;
+    return {
+        row: Number(match[2]) - 1,
+        column: column - 1
+    };
+}
+function encodeCell(row, column) {
+    let value = column + 1;
+    let label = '';
+    while(value > 0){
+        value -= 1;
+        label = String.fromCharCode(65 + value % 26) + label;
+        value = Math.floor(value / 26);
+    }
+    return `${label}${row + 1}`;
+}
+function work_xlsx_protection_attributes(element) {
+    return Object.fromEntries(Array.from(element.attributes).map((item)=>[
+            item.name,
+            item.value
+        ]));
+}
+function copyAttributes(element, source) {
+    for (const [name, value] of Object.entries(source ?? {}))if (/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(name)) element.setAttribute(name, value);
+}
+function hasCredentialAttributes(source) {
+    return Boolean(source.password || source.hashValue || source.saltValue || source.securityDescriptor);
+}
+function work_xlsx_protection_booleanAttribute(element, name, fallback) {
+    const value = attribute(element, name)?.toLowerCase();
+    if ('1' === value || 'true' === value || 'on' === value) return true;
+    if ('0' === value || 'false' === value || 'off' === value) return false;
+    return fallback;
+}
+function nonNegativeInteger(value) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    return Number(value);
+}
+function work_xlsx_protection_positiveInteger(value) {
+    const parsed = nonNegativeInteger(value);
+    return null !== parsed && parsed > 0 ? parsed : null;
+}
+function sameProtection(left, right) {
+    return left.locked === right.locked && left.hidden === right.hidden;
+}
+const SPREADSHEET_NAMESPACE = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const work_xlsx_pivot_xml_RELATIONSHIP_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+function createXlsxPivotXmlParts(content, pivot, cacheId) {
+    const sourceSheet = content.sheets.find((sheet)=>sheet.id === pivot.sourceSheetId);
+    const ranges = parseSpreadsheetCellRanges(pivot.sourceReference);
+    const fields = spreadsheetPivotFields(content, pivot);
+    if (!sourceSheet || ranges?.length !== 1 || !fields.length || !pivot.outputReference) return null;
+    const sourceRange = ranges[0];
+    const dimensionIndexes = new Set([
+        ...pivot.rowFields,
+        ...pivot.columnFields,
+        ...(pivot.reportFilters ?? []).map((filter)=>filter.fieldIndex)
+    ]);
+    const cacheFields = fields.map((field)=>{
+        const values = [];
+        for(let row = sourceRange.row[0] + 1; row <= sourceRange.row[1]; row += 1)values.push(pivotSourceValue(sourceSheet.data?.[row]?.[sourceRange.column[0] + field.index]));
+        return {
+            name: field.name,
+            values,
+            sharedItems: dimensionIndexes.has(field.index) ? uniqueSortedPivotValues(values) : void 0
+        };
+    });
+    return {
+        table: pivotTableXml(pivot, cacheFields, cacheId),
+        cacheDefinition: pivotCacheDefinitionXml(sourceSheet, pivot, cacheFields),
+        cacheRecords: pivotCacheRecordsXml(cacheFields)
+    };
+}
+function xlsxPivotAggregation(aggregation) {
+    if ('count' === aggregation) return 'countNums';
+    if ('counta' === aggregation) return 'count';
+    if ('stdDevP' === aggregation) return 'stdDevp';
+    if ('varP' === aggregation) return 'varp';
+    return aggregation;
+}
+function workPivotAggregation(value) {
+    if (!value || 'sum' === value) return 'sum';
+    if ('countNums' === value) return 'count';
+    if ('count' === value) return 'counta';
+    if ('average' === value) return 'average';
+    if ('max' === value) return 'max';
+    if ('min' === value) return 'min';
+    if ('product' === value) return 'product';
+    if ('stdDev' === value) return 'stdDev';
+    if ('stdDevp' === value) return 'stdDevP';
+    if ('var' === value) return 'var';
+    if ('varp' === value) return 'varP';
+    return null;
+}
+function pivotTableXml(pivot, fields, cacheId) {
+    const dataFieldIndexes = new Set(pivot.values.map((value)=>value.fieldIndex));
+    const reportFilterIndexes = new Set((pivot.reportFilters ?? []).map((filter)=>filter.fieldIndex));
+    const pivotFields = fields.map((field, fieldIndex)=>{
+        const row = pivot.rowFields.includes(fieldIndex);
+        const column = pivot.columnFields.includes(fieldIndex);
+        const page = reportFilterIndexes.has(fieldIndex);
+        const attributes = [
+            row ? 'axis="axisRow"' : '',
+            column ? 'axis="axisCol"' : '',
+            page ? 'axis="axisPage"' : '',
+            dataFieldIndexes.has(fieldIndex) ? 'dataField="1"' : '',
+            'compact="0"',
+            'outline="0"',
+            'showAll="0"',
+            'defaultSubtotal="0"'
+        ].filter(Boolean).join(' ');
+        if (!row && !column && !page) return `<pivotField ${attributes}/>`;
+        const items = field.sharedItems ?? [];
+        return [
+            `<pivotField ${attributes}>`,
+            `<items count="${items.length + 1}">`,
+            ...items.map((_item, index)=>`<item x="${index}"/>`),
+            '<item t="default"/>',
+            '</items>',
+            '</pivotField>'
+        ].join('');
+    }).join('');
+    const rowFields = pivot.rowFields.map((fieldIndex)=>`<field x="${fieldIndex}"/>`).join('');
+    const columnFieldIndexes = [
+        ...pivot.columnFields
+    ];
+    if (pivot.values.length > 1) columnFieldIndexes.push(-2);
+    const columnFields = columnFieldIndexes.map((fieldIndex)=>`<field x="${fieldIndex}"/>`).join('');
+    const pageFields = (pivot.reportFilters ?? []).map((filter)=>{
+        const items = fields[filter.fieldIndex]?.sharedItems ?? [];
+        const selectedIndex = void 0 === filter.selectedItem ? items.length : items.findIndex((item)=>pivotSourceFilterKey(item) === spreadsheetPivotFilterValueKey(filter.selectedItem));
+        return `<pageField fld="${filter.fieldIndex}" hier="-1" item="${selectedIndex >= 0 ? selectedIndex : items.length}"/>`;
+    }).join('');
+    const dataFields = pivot.values.map((value)=>{
+        const caption = value.caption?.trim() || fields[value.fieldIndex]?.name || `Value ${value.fieldIndex + 1}`;
+        return `<dataField name="${work_xlsx_pivot_xml_escapeXml(caption)}" fld="${value.fieldIndex}" subtotal="${xlsxPivotAggregation(value.aggregation)}" baseField="0" baseItem="0"/>`;
+    }).join('');
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        `<pivotTableDefinition xmlns="${SPREADSHEET_NAMESPACE}" name="${work_xlsx_pivot_xml_escapeXml(pivot.name)}" cacheId="${cacheId}"`,
+        ' applyNumberFormats="0" applyBorderFormats="0" applyFontFormats="0" applyPatternFormats="0"',
+        ' applyAlignmentFormats="0" applyWidthHeightFormats="1" dataCaption="值" updatedVersion="8"',
+        ' minRefreshableVersion="3" createdVersion="8" useAutoFormatting="1" compact="0" compactData="0"',
+        ` rowGrandTotals="${pivot.rowGrandTotals ? 1 : 0}" colGrandTotals="${pivot.columnGrandTotals ? 1 : 0}">`,
+        `<location ref="${work_xlsx_pivot_xml_escapeXml(pivotTableReference(pivot))}" firstHeaderRow="1" firstDataRow="1" firstDataCol="${Math.max(1, pivot.rowFields.length)}"/>`,
+        `<pivotFields count="${fields.length}">${pivotFields}</pivotFields>`,
+        `<rowFields count="${pivot.rowFields.length}">${rowFields}</rowFields>`,
+        '<rowItems count="1"><i t="grand"><x/></i></rowItems>',
+        columnFieldIndexes.length ? `<colFields count="${columnFieldIndexes.length}">${columnFields}</colFields>` : '',
+        '<colItems count="1"><i t="grand"><x/></i></colItems>',
+        pageFields ? `<pageFields count="${pivot.reportFilters.length}">${pageFields}</pageFields>` : '',
+        `<dataFields count="${pivot.values.length}">${dataFields}</dataFields>`,
+        `<pivotTableStyleInfo name="${work_xlsx_pivot_xml_escapeXml(pivot.styleName || 'PivotStyleLight16')}" showRowHeaders="1" showColHeaders="1" showRowStripes="0" showColStripes="0" showLastColumn="1"/>`,
+        '</pivotTableDefinition>'
+    ].join('');
+}
+function pivotTableReference(pivot) {
+    const ranges = parseSpreadsheetCellRanges(pivot.outputReference ?? '');
+    const reportFilterRows = pivot.reportFilters?.length ? pivot.reportFilters.length + 1 : 0;
+    if (ranges?.length !== 1 || !reportFilterRows) return pivot.outputReference ?? pivot.anchor;
+    const range = ranges[0];
+    const tableStartRow = range.row[0] + reportFilterRows;
+    if (tableStartRow > range.row[1]) return pivot.outputReference ?? pivot.anchor;
+    return formatSpreadsheetCellRanges([
+        {
+            row: [
+                tableStartRow,
+                range.row[1]
+            ],
+            column: [
+                range.column[0],
+                range.column[1]
+            ]
+        }
+    ]);
+}
+function pivotCacheDefinitionXml(sourceSheet, pivot, fields) {
+    const recordCount = fields[0]?.values.length ?? 0;
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        `<pivotCacheDefinition xmlns="${SPREADSHEET_NAMESPACE}" xmlns:r="${work_xlsx_pivot_xml_RELATIONSHIP_NAMESPACE}" r:id="rId1"`,
+        ` saveData="1" refreshOnLoad="${pivot.refreshOnLoad ? 1 : 0}" enableRefresh="1"`,
+        ` createdVersion="8" refreshedVersion="8" minRefreshableVersion="3" recordCount="${recordCount}">`,
+        '<cacheSource type="worksheet">',
+        `<worksheetSource ref="${work_xlsx_pivot_xml_escapeXml(pivot.sourceReference)}" sheet="${work_xlsx_pivot_xml_escapeXml(sourceSheet.name)}"/>`,
+        '</cacheSource>',
+        `<cacheFields count="${fields.length}">`,
+        ...fields.map((field)=>pivotCacheFieldXml(field)),
+        '</cacheFields>',
+        '</pivotCacheDefinition>'
+    ].join('');
+}
+function pivotCacheFieldXml(field) {
+    const values = field.sharedItems ?? field.values;
+    const statistics = pivotValueStatistics(values);
+    const attributes = [
+        `containsBlank="${statistics.blank ? 1 : 0}"`,
+        `containsString="${statistics.string ? 1 : 0}"`,
+        `containsNumber="${statistics.number ? 1 : 0}"`,
+        `containsInteger="${statistics.integer ? 1 : 0}"`,
+        `containsDate="${statistics.date ? 1 : 0}"`,
+        `containsMixedTypes="${statistics.typeCount > 1 ? 1 : 0}"`,
+        `containsSemiMixedTypes="${statistics.string && statistics.typeCount > 1 ? 1 : 0}"`
+    ];
+    if (!field.sharedItems) return `<cacheField name="${work_xlsx_pivot_xml_escapeXml(field.name)}" numFmtId="0"><sharedItems ${attributes.join(' ')}/></cacheField>`;
+    return [
+        `<cacheField name="${work_xlsx_pivot_xml_escapeXml(field.name)}" numFmtId="0">`,
+        `<sharedItems count="${field.sharedItems.length}" ${attributes.join(' ')}>`,
+        ...field.sharedItems.map((value)=>pivotCacheValueXml(value)),
+        '</sharedItems>',
+        '</cacheField>'
+    ].join('');
+}
+function pivotCacheRecordsXml(fields) {
+    const recordCount = fields[0]?.values.length ?? 0;
+    const sharedIndexes = fields.map((field)=>field.sharedItems ? new Map(field.sharedItems.map((value, index)=>[
+                pivotValueKey(value),
+                index
+            ])) : void 0);
+    const records = [];
+    for(let row = 0; row < recordCount; row += 1){
+        records.push('<r>');
+        for(let column = 0; column < fields.length; column += 1){
+            const value = fields[column].values[row];
+            const sharedIndex = sharedIndexes[column]?.get(pivotValueKey(value));
+            records.push(void 0 === sharedIndex ? pivotCacheValueXml(value) : `<x v="${sharedIndex}"/>`);
+        }
+        records.push('</r>');
+    }
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        `<pivotCacheRecords xmlns="${SPREADSHEET_NAMESPACE}" count="${recordCount}">`,
+        ...records,
+        '</pivotCacheRecords>'
+    ].join('');
+}
+function pivotSourceValue(cell) {
+    const value = cell?.v ?? cell?.m ?? null;
+    if (null == value || '' === value) return {
+        value: null,
+        type: 'blank'
+    };
+    if (cell?.ct?.t === 'e') return {
+        value: String(cell.m ?? cell.v ?? '#VALUE!'),
+        type: 'error'
+    };
+    if (value instanceof Date) return {
+        value,
+        type: 'date'
+    };
+    if ('number' == typeof value && Number.isFinite(value)) return {
+        value,
+        type: 'number'
+    };
+    if ('boolean' == typeof value) return {
+        value,
+        type: 'boolean'
+    };
+    return {
+        value: String(value),
+        type: 'string'
+    };
+}
+function uniqueSortedPivotValues(values) {
+    const unique = new Map(values.map((value)=>[
+            pivotValueKey(value),
+            value
+        ]));
+    return Array.from(unique.values()).sort((left, right)=>pivotValueDisplay(left).localeCompare(pivotValueDisplay(right), 'zh-CN', {
+            numeric: true,
+            sensitivity: 'base'
+        }));
+}
+function pivotCacheValueXml(value) {
+    if ('blank' === value.type) return '<m/>';
+    if ('number' === value.type) return `<n v="${Number(value.value)}"/>`;
+    if ('boolean' === value.type) return `<b v="${value.value ? 1 : 0}"/>`;
+    if ('date' === value.type) {
+        const date = value.value instanceof Date ? value.value.toISOString() : String(value.value);
+        return `<d v="${work_xlsx_pivot_xml_escapeXml(date)}"/>`;
+    }
+    if ('error' === value.type) return `<e v="${work_xlsx_pivot_xml_escapeXml(String(value.value))}"/>`;
+    return `<s v="${work_xlsx_pivot_xml_escapeXml(String(value.value))}"/>`;
+}
+function pivotValueKey(value) {
+    const raw = value.value instanceof Date ? value.value.toISOString() : value.value;
+    return `${value.type}:${String(raw ?? '')}`;
+}
+function pivotSourceFilterKey(value) {
+    if ('blank' === value.type) return 'blank:';
+    if ('date' === value.type) return `string:${value.value instanceof Date ? value.value.toISOString() : String(value.value)}`;
+    if ('boolean' === value.type) return `boolean:${String(Boolean(value.value))}`;
+    if ('number' === value.type) return `number:${String(Number(value.value))}`;
+    return `string:${String(value.value ?? '')}`;
+}
+function pivotValueDisplay(value) {
+    if (value.value instanceof Date) return value.value.toISOString();
+    return String(value.value ?? '');
+}
+function pivotValueStatistics(values) {
+    const types = new Set(values.filter((value)=>'blank' !== value.type).map((value)=>value.type));
+    return {
+        blank: values.some((value)=>'blank' === value.type),
+        string: types.has('string') || types.has('error'),
+        number: types.has('number'),
+        integer: types.has('number') && values.filter((value)=>'number' === value.type).every((value)=>Number.isInteger(Number(value.value))),
+        date: types.has('date'),
+        typeCount: types.size
+    };
+}
+function work_xlsx_pivot_xml_escapeXml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+}
+const work_xlsx_pivots_PACKAGE_RELATIONSHIP_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const DOCUMENT_RELATIONSHIP_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+const PIVOT_TABLE_RELATIONSHIP = `${DOCUMENT_RELATIONSHIP_NAMESPACE}/pivotTable`;
+const PIVOT_CACHE_DEFINITION_RELATIONSHIP = `${DOCUMENT_RELATIONSHIP_NAMESPACE}/pivotCacheDefinition`;
+const PIVOT_CACHE_RECORDS_RELATIONSHIP = `${DOCUMENT_RELATIONSHIP_NAMESPACE}/pivotCacheRecords`;
+const PIVOT_TABLE_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml';
+const PIVOT_CACHE_DEFINITION_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml';
+const PIVOT_CACHE_RECORDS_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml';
+async function patchXlsxPivotTables(buffer, content) {
+    if (!content.sheets.some((sheet)=>sheet.pivotTables?.length)) return buffer;
+    const archive = await work_ooxml_package_OoxmlPackage.load(buffer);
+    const worksheetParts = await workbookWorksheetParts(archive);
+    const candidates = content.sheets.flatMap((ownerSheet)=>(ownerSheet.pivotTables ?? []).flatMap((pivot)=>{
+            if (!ownerSheet.id || !spreadsheetPivotValidation(content, ownerSheet.id, pivot).valid) return [];
+            const worksheetPart = worksheetParts.get(ownerSheet.name.slice(0, 31) || '工作表');
+            return worksheetPart ? [
+                {
+                    ownerSheet,
+                    pivot,
+                    worksheetPart
+                }
+            ] : [];
+        }));
+    if (!candidates.length) return buffer;
+    const zip = await jszip.loadAsync(buffer);
+    const workbookEntry = zip.file('xl/workbook.xml');
+    const workbookRelationshipsEntry = zip.file('xl/_rels/workbook.xml.rels');
+    if (!workbookEntry || !workbookRelationshipsEntry) return buffer;
+    const workbook = parseXml(await workbookEntry.async('text'), 'xl/workbook.xml');
+    const workbookRelationships = parseXml(await workbookRelationshipsEntry.async('text'), 'xl/_rels/workbook.xml.rels');
+    removeRelationships(workbookRelationships, '/pivotCacheDefinition');
+    for (const existing of directChildren(workbook.documentElement, 'pivotCaches'))existing.remove();
+    const pivotCaches = workbook.createElementNS(workbook.documentElement.namespaceURI, 'pivotCaches');
+    ensureRelationshipNamespace(workbook);
+    const worksheetRelationships = new Map();
+    const contentTypeParts = [];
+    let exported = 0;
+    for (const [index, candidate] of candidates.entries()){
+        const partIndex = index + 1;
+        const cacheId = partIndex;
+        const parts = createXlsxPivotXmlParts(content, candidate.pivot, cacheId);
+        if (!parts) continue;
+        const pivotTablePath = `xl/pivotTables/pivotTable${partIndex}.xml`;
+        const pivotCacheDefinitionPath = `xl/pivotCache/pivotCacheDefinition${partIndex}.xml`;
+        const pivotCacheRecordsPath = `xl/pivotCache/pivotCacheRecords${partIndex}.xml`;
+        const workbookRelationshipId = appendRelationship(workbookRelationships, PIVOT_CACHE_DEFINITION_RELATIONSHIP, `pivotCache/pivotCacheDefinition${partIndex}.xml`);
+        const pivotCache = workbook.createElementNS(workbook.documentElement.namespaceURI, 'pivotCache');
+        pivotCache.setAttribute('cacheId', String(cacheId));
+        pivotCache.setAttributeNS(DOCUMENT_RELATIONSHIP_NAMESPACE, 'r:id', workbookRelationshipId);
+        pivotCaches.append(pivotCache);
+        const worksheetRelationshipDocument = worksheetRelationships.get(candidate.worksheetPart) ?? await readRelationshipsDocument(zip, work_xlsx_pivots_relationshipsPartPath(candidate.worksheetPart));
+        if (!worksheetRelationships.has(candidate.worksheetPart)) {
+            removeRelationships(worksheetRelationshipDocument, '/pivotTable');
+            worksheetRelationships.set(candidate.worksheetPart, worksheetRelationshipDocument);
+        }
+        appendRelationship(worksheetRelationshipDocument, PIVOT_TABLE_RELATIONSHIP, `../pivotTables/pivotTable${partIndex}.xml`);
+        zip.file(pivotTablePath, parts.table);
+        zip.file(pivotCacheDefinitionPath, parts.cacheDefinition);
+        zip.file(pivotCacheRecordsPath, parts.cacheRecords);
+        zip.file(`xl/pivotTables/_rels/pivotTable${partIndex}.xml.rels`, relationshipsXml([
+            {
+                id: 'rId1',
+                type: PIVOT_CACHE_DEFINITION_RELATIONSHIP,
+                target: `../pivotCache/pivotCacheDefinition${partIndex}.xml`
+            }
+        ]));
+        zip.file(`xl/pivotCache/_rels/pivotCacheDefinition${partIndex}.xml.rels`, relationshipsXml([
+            {
+                id: 'rId1',
+                type: PIVOT_CACHE_RECORDS_RELATIONSHIP,
+                target: `pivotCacheRecords${partIndex}.xml`
+            }
+        ]));
+        contentTypeParts.push({
+            path: pivotTablePath,
+            contentType: PIVOT_TABLE_CONTENT_TYPE
+        }, {
+            path: pivotCacheDefinitionPath,
+            contentType: PIVOT_CACHE_DEFINITION_CONTENT_TYPE
+        }, {
+            path: pivotCacheRecordsPath,
+            contentType: PIVOT_CACHE_RECORDS_CONTENT_TYPE
+        });
+        exported += 1;
+    }
+    if (!exported) return buffer;
+    insertWorkbookPivotCaches(workbook, pivotCaches);
+    zip.file('xl/workbook.xml', new XMLSerializer().serializeToString(workbook));
+    zip.file('xl/_rels/workbook.xml.rels', new XMLSerializer().serializeToString(workbookRelationships));
+    for (const [worksheetPart, relationships] of worksheetRelationships)zip.file(work_xlsx_pivots_relationshipsPartPath(worksheetPart), new XMLSerializer().serializeToString(relationships));
+    await work_xlsx_pivots_updateContentTypes(zip, contentTypeParts);
+    return zip.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+async function inspectXlsxPivotTables(archive) {
+    if (!archive.has('xl/workbook.xml')) return {
+        tables: [],
+        unsupported: [],
+        detected: 0
+    };
+    const workbook = await archive.xml('xl/workbook.xml');
+    const workbookRelationships = await archive.relationships('xl/workbook.xml');
+    const cacheById = new Map();
+    for (const cache of directChildren(firstDescendant(workbook, 'pivotCaches') ?? workbook.documentElement, 'pivotCache')){
+        const cacheId = integerAttribute(cache, 'cacheId');
+        const relationship = workbookRelationships.get(attribute(cache, 'r:id') ?? attribute(cache, 'id') ?? '');
+        if (null !== cacheId && relationship && archive.has(relationship.target)) cacheById.set(cacheId, parsePivotCache(await archive.xml(relationship.target)));
+    }
+    const worksheetParts = await workbookWorksheetParts(archive);
+    const tables = [];
+    const unsupported = [];
+    let detected = 0;
+    for (const [destinationSheetName, worksheetPart] of worksheetParts){
+        const relationships = await archive.relationships(worksheetPart);
+        for (const relationship of relationships.values()){
+            if (!relationship.type.endsWith('/pivotTable')) continue;
+            detected += 1;
+            if ('External' === relationship.targetMode || !archive.has(relationship.target)) {
+                unsupported.push({
+                    code: 'xlsx.pivots.relationship',
+                    message: 'The pivot-table relationship is external or missing.',
+                    location: destinationSheetName
+                });
+                continue;
+            }
+            const parsed = parsePivotTable(await archive.xml(relationship.target), destinationSheetName, cacheById);
+            if ('unsupported' in parsed) unsupported.push(parsed.unsupported);
+            else tables.push(parsed.table);
+        }
+    }
+    if (!detected && (archive.paths('xl/pivotTables/').length || archive.paths('xl/pivotCache/').length)) unsupported.push({
+        code: 'xlsx.pivots.orphaned',
+        message: 'Pivot-table package parts are present without a readable worksheet relationship.'
+    });
+    if (archive.paths('xl/slicers/').length || archive.paths('xl/slicerCaches/').length) unsupported.push({
+        code: 'xlsx.pivots.slicers',
+        message: 'Pivot slicers and timelines are not editable in Work.'
+    });
+    return {
+        tables,
+        unsupported,
+        detected: Math.max(detected, tables.length + unsupported.length)
+    };
+}
+function applyImportedXlsxPivotTables(content, imported) {
+    if (!imported?.tables.length) return content;
+    const sheets = content.sheets.map((sheet)=>({
+            ...sheet,
+            pivotTables: sheet.pivotTables ? [
+                ...sheet.pivotTables
+            ] : void 0
+        }));
+    const byName = new Map(sheets.map((sheet)=>[
+            sheet.name,
+            sheet
+        ]));
+    for (const table of imported.tables){
+        const ownerSheet = byName.get(table.destinationSheetName);
+        const sourceSheet = byName.get(table.sourceSheetName);
+        if (!ownerSheet || !sourceSheet?.id) continue;
+        const pivot = {
+            id: createWorkId('pivot'),
+            name: table.name,
+            sourceSheetId: sourceSheet.id,
+            sourceReference: table.sourceReference,
+            anchor: table.anchor,
+            rowFields: [
+                ...table.rowFields
+            ],
+            columnFields: [
+                ...table.columnFields
+            ],
+            reportFilters: table.reportFilters.map((filter)=>({
+                    ...filter
+                })),
+            values: table.values.map((value)=>({
+                    ...value
+                })),
+            rowGrandTotals: table.rowGrandTotals,
+            columnGrandTotals: table.columnGrandTotals,
+            styleName: table.styleName,
+            refreshOnLoad: table.refreshOnLoad,
+            outputReference: table.outputReference
+        };
+        ownerSheet.pivotTables = [
+            ...ownerSheet.pivotTables ?? [],
+            pivot
+        ];
+    }
+    return {
+        ...content,
+        sheets
+    };
+}
+async function workbookWorksheetParts(archive) {
+    if (!archive.has('xl/workbook.xml')) return new Map();
+    const workbook = await archive.xml('xl/workbook.xml');
+    const relationships = await archive.relationships('xl/workbook.xml');
+    const parts = new Map();
+    for (const sheet of directChildren(firstDescendant(workbook, 'sheets') ?? workbook.documentElement, 'sheet')){
+        const name = attribute(sheet, 'name');
+        const relationship = relationships.get(attribute(sheet, 'r:id') ?? attribute(sheet, 'id') ?? '');
+        if (name && relationship?.type.endsWith('/worksheet')) parts.set(name, relationship.target);
+    }
+    return parts;
+}
+function parsePivotCache(document) {
+    const root = document.documentElement;
+    const cacheSource = directChild(root, 'cacheSource');
+    const sourceType = attribute(cacheSource ?? root, 'type');
+    const worksheetSource = directChild(cacheSource ?? root, 'worksheetSource');
+    const sourceSheetName = attribute(worksheetSource ?? root, 'sheet')?.trim() || void 0;
+    const sourceReference = attribute(worksheetSource ?? root, 'ref')?.trim() || void 0;
+    const cacheFields = directChildren(directChild(root, 'cacheFields') ?? root, 'cacheField');
+    const fields = cacheFields.map((field, index)=>attribute(field, 'name')?.trim() || `Field ${index + 1}`);
+    const fieldItems = cacheFields.map((field)=>directChildren(directChild(field, 'sharedItems') ?? field).flatMap((item)=>{
+            const value = pivotCacheItemValue(item);
+            return value ? [
+                value.value
+            ] : [];
+        }));
+    let unsupported;
+    if ('worksheet' !== sourceType || !sourceSheetName || !sourceReference || attribute(worksheetSource ?? root, 'name')) unsupported = {
+        code: 'external' === sourceType ? 'xlsx.pivots.external-source' : 'xlsx.pivots.source',
+        message: 'Only worksheet pivots with an explicit cell-range source are editable.'
+    };
+    else if (descendants(root, 'fieldGroup').length || directChildren(directChild(root, 'cacheFields') ?? root, 'cacheField').some((field)=>attribute(field, 'formula'))) unsupported = {
+        code: 'xlsx.pivots.grouping',
+        message: 'Grouped or calculated pivot-cache fields remain cached values only.'
+    };
+    else if (descendants(root, 'calculatedItems').length || descendants(root, 'calculatedMembers').length) unsupported = {
+        code: 'xlsx.pivots.calculated-items',
+        message: 'Calculated pivot items and members remain cached values only.'
+    };
+    return {
+        sourceSheetName,
+        sourceReference,
+        fields,
+        fieldItems,
+        refreshOnLoad: work_xlsx_pivots_booleanAttribute(root, 'refreshOnLoad'),
+        unsupported
+    };
+}
+function pivotCacheItemValue(element) {
+    const source = attribute(element, 'v');
+    if ('m' === element.localName) return {
+        value: null
+    };
+    if ('b' === element.localName) return {
+        value: '1' === source || source?.toLowerCase() === 'true'
+    };
+    if ('n' === element.localName) {
+        const value = Number(source);
+        return Number.isFinite(value) ? {
+            value
+        } : null;
+    }
+    if ('s' === element.localName || 'e' === element.localName || 'd' === element.localName) return {
+        value: source ?? ''
+    };
+    return null;
+}
+function parsePivotReportFilters(root, cache, location) {
+    const pageFields = directChild(root, 'pageFields');
+    if (!pageFields) return {
+        reportFilters: []
+    };
+    const pageWrap = integerAttribute(root, 'pageWrap') ?? 0;
+    if (pageWrap > 0 || work_xlsx_pivots_booleanAttribute(root, 'pageOverThenDown')) return {
+        unsupported: {
+            code: 'xlsx.pivots.report-filter-layout',
+            message: 'Wrapped or horizontal report-filter layouts remain cached values only.',
+            location
+        }
+    };
+    const pivotFields = directChildren(directChild(root, 'pivotFields') ?? root, 'pivotField');
+    const reportFilters = [];
+    for (const pageField of directChildren(pageFields, 'pageField')){
+        const fieldIndex = integerAttribute(pageField, 'fld');
+        const pivotField = null === fieldIndex ? void 0 : pivotFields[fieldIndex];
+        if (null === fieldIndex || !pivotField || !cache.fields[fieldIndex]) return {
+            unsupported: {
+                code: 'xlsx.pivots.report-filter-field',
+                message: 'A report filter refers to a missing pivot-cache field.',
+                location
+            }
+        };
+        const items = directChildren(directChild(pivotField, 'items') ?? pivotField, 'item');
+        if (work_xlsx_pivots_booleanAttribute(pivotField, 'multipleItemSelectionAllowed') || items.some((item)=>work_xlsx_pivots_booleanAttribute(item, 'h'))) return {
+            unsupported: {
+                code: 'xlsx.pivots.report-filter-multi-select',
+                message: 'Multi-selection report filters remain cached values only.',
+                location
+            }
+        };
+        const itemIndex = integerAttribute(pageField, 'item');
+        if (null === itemIndex) {
+            reportFilters.push({
+                fieldIndex
+            });
+            continue;
+        }
+        const pivotItem = items[itemIndex];
+        if (!pivotItem) return {
+            unsupported: {
+                code: 'xlsx.pivots.report-filter-item',
+                message: 'A report filter refers to a missing pivot item.',
+                location
+            }
+        };
+        if ('default' === attribute(pivotItem, 't')) {
+            reportFilters.push({
+                fieldIndex
+            });
+            continue;
+        }
+        const sharedItemIndex = integerAttribute(pivotItem, 'x');
+        const sharedItems = cache.fieldItems[fieldIndex] ?? [];
+        if (null === sharedItemIndex || sharedItemIndex < 0 || sharedItemIndex >= sharedItems.length) return {
+            unsupported: {
+                code: 'xlsx.pivots.report-filter-item',
+                message: 'A report filter item is missing from the pivot cache.',
+                location
+            }
+        };
+        reportFilters.push({
+            fieldIndex,
+            selectedItem: sharedItems[sharedItemIndex]
+        });
+    }
+    return {
+        reportFilters
+    };
+}
+function parsePivotTable(document, destinationSheetName, cacheById) {
+    const root = document.documentElement;
+    const name = attribute(root, 'name')?.trim() || 'PivotTable';
+    const locationLabel = destinationSheetName ? `${destinationSheetName} · ${name}` : name;
+    const cacheId = integerAttribute(root, 'cacheId');
+    const cache = null === cacheId ? void 0 : cacheById.get(cacheId);
+    if (!cache || cache.unsupported || !cache.sourceSheetName || !cache.sourceReference) return {
+        unsupported: {
+            ...cache?.unsupported ?? {
+                code: 'xlsx.pivots.cache',
+                message: 'The pivot cache definition is missing or unreadable.'
+            },
+            location: locationLabel
+        }
+    };
+    if (directChildren(root, 'filters').length || work_xlsx_pivots_booleanAttribute(root, 'dataOnRows')) return {
+        unsupported: {
+            code: 'xlsx.pivots.filters-layout',
+            message: 'Label or value filters and values-on-rows layouts remain cached values only.',
+            location: locationLabel
+        }
+    };
+    const parsedReportFilters = parsePivotReportFilters(root, cache, locationLabel);
+    if ('unsupported' in parsedReportFilters) return parsedReportFilters;
+    const reportFilters = parsedReportFilters.reportFilters;
+    const rowFields = readPivotFieldIndexes(directChild(root, 'rowFields'));
+    const columnFields = readPivotFieldIndexes(directChild(root, 'colFields')).filter((index)=>-2 !== index);
+    if (rowFields.includes(-2)) return {
+        unsupported: {
+            code: 'xlsx.pivots.values-on-rows',
+            message: 'Values-on-rows pivot layouts remain cached values only.',
+            location: locationLabel
+        }
+    };
+    const values = [];
+    for (const dataField of directChildren(directChild(root, 'dataFields') ?? root, 'dataField')){
+        const fieldIndex = integerAttribute(dataField, 'fld');
+        const aggregation = workPivotAggregation(attribute(dataField, 'subtotal'));
+        if (null === fieldIndex || !aggregation || !cache.fields[fieldIndex]) return {
+            unsupported: {
+                code: 'xlsx.pivots.aggregation',
+                message: 'The pivot uses an unsupported value calculation or field reference.',
+                location: locationLabel
+            }
+        };
+        values.push({
+            fieldIndex,
+            aggregation,
+            caption: attribute(dataField, 'name')?.trim() || void 0
+        });
+    }
+    const location = directChild(root, 'location');
+    const outputReference = attribute(location ?? root, 'ref')?.trim() ?? '';
+    const outputRange = parseSpreadsheetCellRanges(outputReference);
+    const reportFilterFields = reportFilters.map((filter)=>filter.fieldIndex);
+    if (!rowFields.length || !values.length || outputRange?.length !== 1 || [
+        ...rowFields,
+        ...columnFields,
+        ...reportFilterFields
+    ].some((index)=>index < 0 || !cache.fields[index]) || new Set([
+        ...rowFields,
+        ...columnFields,
+        ...reportFilterFields
+    ]).size !== rowFields.length + columnFields.length + reportFilterFields.length) return {
+        unsupported: {
+            code: 'xlsx.pivots.layout',
+            message: 'The pivot layout cannot be represented by the editable Work pivot model.',
+            location: locationLabel
+        }
+    };
+    const reportFilterRows = reportFilters.length ? reportFilters.length + 1 : 0;
+    if (outputRange[0].row[0] < reportFilterRows) return {
+        unsupported: {
+            code: 'xlsx.pivots.report-filter-layout',
+            message: 'The report-filter placement cannot be represented by the Work report layout.',
+            location: locationLabel
+        }
+    };
+    const ownedRange = {
+        row: [
+            outputRange[0].row[0] - reportFilterRows,
+            outputRange[0].row[1]
+        ],
+        column: [
+            outputRange[0].column[0],
+            outputRange[0].column[1]
+        ]
+    };
+    const anchor = formatSpreadsheetCellRanges([
+        {
+            row: [
+                ownedRange.row[0],
+                ownedRange.row[0]
+            ],
+            column: [
+                ownedRange.column[0],
+                ownedRange.column[0]
+            ]
+        }
+    ]);
+    return {
+        table: {
+            destinationSheetName,
+            sourceSheetName: cache.sourceSheetName,
+            sourceReference: cache.sourceReference,
+            name,
+            anchor,
+            outputReference: formatSpreadsheetCellRanges([
+                ownedRange
+            ]),
+            rowFields,
+            columnFields,
+            reportFilters,
+            values,
+            rowGrandTotals: work_xlsx_pivots_booleanAttribute(root, 'rowGrandTotals', true),
+            columnGrandTotals: work_xlsx_pivots_booleanAttribute(root, 'colGrandTotals', true),
+            styleName: attribute(directChild(root, 'pivotTableStyleInfo') ?? root, 'name') || 'PivotStyleLight16',
+            refreshOnLoad: cache.refreshOnLoad
+        }
+    };
+}
+function readPivotFieldIndexes(parent) {
+    if (!parent) return [];
+    return directChildren(parent, 'field').flatMap((field)=>{
+        const index = integerAttribute(field, 'x');
+        return null === index ? [] : [
+            index
+        ];
+    });
+}
+async function readRelationshipsDocument(zip, path) {
+    const entry = zip.file(path);
+    return entry ? parseXml(await entry.async('text'), path) : parseXml(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${work_xlsx_pivots_PACKAGE_RELATIONSHIP_NAMESPACE}"/>`, path);
+}
+function appendRelationship(document, type, target) {
+    const id = work_xlsx_pivots_nextRelationshipId(document);
+    const relationship = document.createElementNS(work_xlsx_pivots_PACKAGE_RELATIONSHIP_NAMESPACE, 'Relationship');
+    relationship.setAttribute('Id', id);
+    relationship.setAttribute('Type', type);
+    relationship.setAttribute('Target', target);
+    document.documentElement.append(relationship);
+    return id;
+}
+function removeRelationships(document, typeSuffix) {
+    for (const relationship of directChildren(document.documentElement, 'Relationship'))if (attribute(relationship, 'Type')?.endsWith(typeSuffix)) relationship.remove();
+}
+function work_xlsx_pivots_nextRelationshipId(document) {
+    const ids = new Set(directChildren(document.documentElement, 'Relationship').map((relationship)=>attribute(relationship, 'Id')).filter((id)=>Boolean(id)));
+    let index = 1;
+    while(ids.has(`rId${index}`))index += 1;
+    return `rId${index}`;
+}
+function relationshipsXml(relationships) {
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        `<Relationships xmlns="${work_xlsx_pivots_PACKAGE_RELATIONSHIP_NAMESPACE}">`,
+        ...relationships.map((relationship)=>`<Relationship Id="${relationship.id}" Type="${relationship.type}" Target="${relationship.target}"/>`),
+        '</Relationships>'
+    ].join('');
+}
+function insertWorkbookPivotCaches(document, pivotCaches) {
+    const laterElements = new Set([
+        'smartTagPr',
+        'smartTagTypes',
+        'webPublishing',
+        'fileRecoveryPr',
+        'webPublishObjects',
+        'extLst'
+    ]);
+    const insertionPoint = directChildren(document.documentElement).find((element)=>laterElements.has(element.localName));
+    document.documentElement.insertBefore(pivotCaches, insertionPoint ?? null);
+}
+function ensureRelationshipNamespace(document) {
+    if (xmlNamespacePrefix(document.documentElement, DOCUMENT_RELATIONSHIP_NAMESPACE)) return;
+    document.documentElement.setAttributeNS(XMLNS_NAMESPACE, 'xmlns:r', DOCUMENT_RELATIONSHIP_NAMESPACE);
+}
+async function work_xlsx_pivots_updateContentTypes(zip, parts) {
+    const entry = zip.file('[Content_Types].xml');
+    if (!entry) return;
+    const document = parseXml(await entry.async('text'), '[Content_Types].xml');
+    const namespace = document.documentElement.namespaceURI;
+    for (const override of directChildren(document.documentElement, 'Override')){
+        const partName = attribute(override, 'PartName') ?? '';
+        if (partName.startsWith('/xl/pivotTables/') || partName.startsWith('/xl/pivotCache/')) override.remove();
+    }
+    for (const part of parts){
+        const override = document.createElementNS(namespace, 'Override');
+        override.setAttribute('PartName', `/${part.path}`);
+        override.setAttribute('ContentType', part.contentType);
+        document.documentElement.append(override);
+    }
+    zip.file('[Content_Types].xml', new XMLSerializer().serializeToString(document));
+}
+function work_xlsx_pivots_relationshipsPartPath(sourcePart) {
+    const segments = sourcePart.split('/');
+    const name = segments.pop() ?? '';
+    return [
+        ...segments,
+        '_rels',
+        `${name}.rels`
+    ].join('/');
+}
+function integerAttribute(element, name) {
+    const source = attribute(element, name);
+    if (null === source || !source.trim()) return null;
+    const value = Number(source);
+    return Number.isInteger(value) ? value : null;
+}
+function work_xlsx_pivots_booleanAttribute(element, name, fallback = false) {
+    const value = attribute(element, name);
+    if (null === value) return fallback;
+    return '1' === value || 'true' === value.toLowerCase();
+}
+function emptySpreadsheetWorksheetCompatibilitySummary() {
+    return {
+        hasArrayFormulas: false,
+        hasComments: false,
+        hasCommentThreads: false,
+        hasLinks: false,
+        hasRichText: false
+    };
+}
+function updateSpreadsheetWorksheetCompatibilitySummary(summary, cell) {
+    const source = cell;
+    if (source.c?.length) {
+        summary.hasComments = true;
+        if (source.c.length > 1 || source.c.some((comment)=>comment.T)) summary.hasCommentThreads = true;
+    }
+    if (source.l?.Target) summary.hasLinks = true;
+    if (source.F) summary.hasArrayFormulas = true;
+    if (source.r) summary.hasRichText = true;
+}
+export { MAX_XLSX_WORKSHEET_IMAGE_BYTES, XlsxCellProtectionWriter, applyImportedXlsxPivotTables, createSpreadsheetFormulaMetadata, createXlsxErrorCell, createXlsxFormulaCell, diagnoseXlsxProtection, emptySpreadsheetWorksheetCompatibilitySummary, inspectXlsxHeaderFooterText, inspectXlsxPivotTables, isEditableXlsxPaperSizeCode, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, isSupportedXlsxChartSeriesFormatting, isSupportedXlsxCombinationChartNodes, isSupportedXlsxWorksheetImageContentType, parseXlsxChartAxes, parseXlsxChartLegend, parseXlsxChartPlotLayout, parseXlsxChartSeriesStyle, parseXlsxErrorBars, parseXlsxTrendline, patchXlsxFormulaFeatures, patchXlsxPivotTables, patchXlsxWorksheetDrawings, readXlsxFormulaFeaturesFromPackage, readXlsxPageSetup, readXlsxProtection, readXlsxWorksheetCharts, readXlsxWorksheetImages, updateSpreadsheetWorksheetCompatibilitySummary, writeXlsxPageSetup, writeXlsxProtection, xlsxChartNodeUsesStackedGrouping, xlsxChartSeriesFormattingShapeProperties, xlsxChartSeriesMarkerXml, xlsxChartSeriesShapePropertiesXml, xlsxWorksheetChartsToSheet, xlsxWorksheetImagesToSheet };