@a3s-lab/office 0.1.0

package/dist/8715.js

@@ -0,0 +1,3959 @@
+import jszip from "jszip";
+import { createOfficeId as createWorkId } from "./1134.js";
+function normalizeWorkSpreadsheetDoughnutHoleSize(value) {
+    const size = Number(value);
+    if (!Number.isFinite(size)) return 50;
+    return Math.min(90, Math.max(10, Math.round(size)));
+}
+function normalizeWorkSpreadsheetRadarStyle(value) {
+    return 'standard' === value || 'filled' === value || 'marker' === value ? value : 'marker';
+}
+function normalizeWorkSpreadsheetScatterStyle(value) {
+    return 'line' === value || 'lineMarker' === value || 'smooth' === value || 'smoothMarker' === value || 'marker' === value ? value : 'marker';
+}
+function normalizeWorkSpreadsheetBubbleScale(value) {
+    const scale = Number(value);
+    if (!Number.isFinite(scale)) return 100;
+    return Math.min(300, Math.max(0, Math.round(scale)));
+}
+function normalizeWorkSpreadsheetBubbleSizeRepresents(value) {
+    return 'width' === value || 'w' === value ? 'width' : 'area';
+}
+function workSpreadsheetChartUsesNumericXAxis(type) {
+    return 'scatter' === type || 'bubble' === type;
+}
+function workSpreadsheetChartSupportsAxes(type) {
+    return 'pie' !== type && 'doughnut' !== type;
+}
+function normalizeWorkSpreadsheetCombinationSeriesType(value) {
+    return 'line' === value || 'area' === value || 'column' === value ? value : 'column';
+}
+function normalizeWorkSpreadsheetChartAxisGroup(value) {
+    return 'secondary' === value ? 'secondary' : 'primary';
+}
+function workSpreadsheetCombinationSeriesTypeLabel(type) {
+    if ('line' === type) return '折线图';
+    if ('area' === type) return '面积图';
+    return '柱形图';
+}
+function workSpreadsheetChartSupportsTrendlines(type) {
+    return 'pie' !== type && 'doughnut' !== type && 'radar' !== type;
+}
+function workSpreadsheetChartSupportsErrorBars(type) {
+    return 'pie' !== type && 'doughnut' !== type && 'radar' !== type;
+}
+function normalizeWorkSpreadsheetErrorBars(source, chartType) {
+    const direction = workSpreadsheetChartUsesNumericXAxis(chartType) && 'x' === source.direction ? 'x' : 'y';
+    const barType = 'plus' === source.barType || 'minus' === source.barType ? source.barType : 'both';
+    const valueType = 'percentage' === source.valueType || 'standardDeviation' === source.valueType || 'standardError' === source.valueType || 'custom' === source.valueType || 'fixedValue' === source.valueType ? source.valueType : 'fixedValue';
+    const fallbackValue = 'percentage' === valueType ? 5 : 1;
+    const numericValue = Number(source.value);
+    const value = Number.isFinite(numericValue) ? Math.max(0, numericValue) : fallbackValue;
+    const plusValues = source.plusValues?.map(normalizedErrorBarAmount);
+    const minusValues = source.minusValues?.map(normalizedErrorBarAmount);
+    return {
+        direction,
+        barType,
+        valueType,
+        ...'fixedValue' === valueType || 'percentage' === valueType || 'standardDeviation' === valueType ? {
+            value
+        } : {},
+        ...false === source.showEndCaps ? {
+            showEndCaps: false
+        } : {},
+        ...'custom' === valueType && 'minus' !== barType && plusValues?.length ? {
+            plusValues
+        } : {},
+        ...'custom' === valueType && 'minus' !== barType && source.plusReference?.trim() ? {
+            plusReference: source.plusReference.trim().replace(/^=/, '')
+        } : {},
+        ...'custom' === valueType && 'plus' !== barType && minusValues?.length ? {
+            minusValues
+        } : {},
+        ...'custom' === valueType && 'plus' !== barType && source.minusReference?.trim() ? {
+            minusReference: source.minusReference.trim().replace(/^=/, '')
+        } : {}
+    };
+}
+function workSpreadsheetErrorBarValueTypeLabel(type) {
+    if ('percentage' === type) return '百分比';
+    if ('standardDeviation' === type) return '标准差';
+    if ('standardError' === type) return '标准误差';
+    if ('custom' === type) return '自定义';
+    return '固定值';
+}
+function workSpreadsheetErrorBarTypeLabel(type) {
+    if ('plus' === type) return '正向';
+    if ('minus' === type) return '负向';
+    return '双向';
+}
+function normalizedErrorBarAmount(value) {
+    return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function normalizeWorkSpreadsheetDataLabelPosition(value) {
+    return 'center' === value || 'insideBase' === value || 'insideEnd' === value || 'outsideEnd' === value || 'left' === value || 'right' === value || 'above' === value || 'below' === value || 'bestFit' === value ? value : 'bestFit';
+}
+function normalizeWorkSpreadsheetDataLabels(source, chartType) {
+    const position = source.position ? normalizeWorkSpreadsheetDataLabelPosition(source.position) : void 0;
+    const separator = 'string' == typeof source.separator ? source.separator.slice(0, 64) : void 0;
+    return {
+        ...true === source.showValue ? {
+            showValue: true
+        } : {},
+        ...true === source.showCategoryName ? {
+            showCategoryName: true
+        } : {},
+        ...true === source.showSeriesName ? {
+            showSeriesName: true
+        } : {},
+        ...true === source.showPercentage && ('pie' === chartType || 'doughnut' === chartType) ? {
+            showPercentage: true
+        } : {},
+        ...true === source.showBubbleSize && 'bubble' === chartType ? {
+            showBubbleSize: true
+        } : {},
+        ...void 0 !== separator ? {
+            separator
+        } : {},
+        ...position ? {
+            position
+        } : {}
+    };
+}
+function workSpreadsheetDataLabelPositionLabel(position) {
+    if ('center' === position) return '居中';
+    if ('insideBase' === position) return '内侧基部';
+    if ('insideEnd' === position) return '内侧末端';
+    if ('outsideEnd' === position) return '外侧末端';
+    if ('left' === position) return '左侧';
+    if ('right' === position) return '右侧';
+    if ('above' === position) return '上方';
+    if ('below' === position) return '下方';
+    return '最佳匹配';
+}
+function normalizeWorkSpreadsheetTrendlineType(value) {
+    return 'exponential' === value || 'logarithmic' === value || 'polynomial' === value || 'power' === value || 'movingAverage' === value || 'linear' === value ? value : 'linear';
+}
+function normalizeWorkSpreadsheetTrendline(trendline) {
+    const type = normalizeWorkSpreadsheetTrendlineType(trendline.type);
+    const name = trendline.name?.trim().slice(0, 255);
+    const order = normalizedInteger(trendline.order, 2, 6, 2);
+    const period = normalizedInteger(trendline.period, 2, 255, 2);
+    const forward = normalizedNonNegativeNumber(trendline.forward);
+    const backward = normalizedNonNegativeNumber(trendline.backward);
+    const intercept = Number.isFinite(trendline.intercept) ? Number(trendline.intercept) : void 0;
+    return {
+        type,
+        ...name ? {
+            name
+        } : {},
+        ...'polynomial' === type ? {
+            order
+        } : {},
+        ...'movingAverage' === type ? {
+            period
+        } : {},
+        ...forward > 0 ? {
+            forward
+        } : {},
+        ...backward > 0 ? {
+            backward
+        } : {},
+        ...void 0 !== intercept ? {
+            intercept
+        } : {},
+        ...true === trendline.displayEquation ? {
+            displayEquation: true
+        } : {},
+        ...true === trendline.displayRSquared ? {
+            displayRSquared: true
+        } : {}
+    };
+}
+function workSpreadsheetTrendlineTypeLabel(type) {
+    if ('exponential' === type) return '指数';
+    if ('logarithmic' === type) return '对数';
+    if ('polynomial' === type) return '多项式';
+    if ('power' === type) return '幂';
+    if ('movingAverage' === type) return '移动平均';
+    return '线性';
+}
+function normalizedInteger(value, minimum, maximum, fallback) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.round(number)));
+}
+function normalizedNonNegativeNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.max(0, number) : 0;
+}
+function workSpreadsheetChartTypeLabel(type) {
+    if ('bar' === type) return '条形图';
+    if ('line' === type) return '折线图';
+    if ('pie' === type) return '饼图';
+    if ('doughnut' === type) return '圆环图';
+    if ('area' === type) return '面积图';
+    if ('radar' === type) return '雷达图';
+    if ('scatter' === type) return '散点图';
+    if ('bubble' === type) return '气泡图';
+    if ('combination' === type) return '组合图';
+    return '柱形图';
+}
+const CELL_REFERENCE = /\$?([A-Z]{1,3})\$?([1-9]\d*)/i;
+const CELL_OR_RANGE = new RegExp(`^${CELL_REFERENCE.source}(?::${CELL_REFERENCE.source})?$`, 'i');
+const COLUMN_RANGE = /^\$?([A-Z]{1,3}):\$?([A-Z]{1,3})$/i;
+const ROW_RANGE = /^\$?([1-9]\d*):\$?([1-9]\d*)$/;
+const DEFINED_NAME = /^[\p{L}_\\][\p{L}\p{N}_.\\]*$/u;
+function isValidSpreadsheetDefinedName(value) {
+    const name = value.trim();
+    if (!name || name.length > 255 || !DEFINED_NAME.test(name) || /^_xlnm\./i.test(name)) return false;
+    if (/^[A-Z]{1,3}[1-9]\d*$/i.test(name) || /^R\d+C\d+$/i.test(name)) return false;
+    return true;
+}
+function normalizeSpreadsheetPrintArea(value) {
+    const parts = splitRangeList(value.trim().replace(/^=/, ''));
+    if (!parts.length) return null;
+    const normalized = parts.map((part)=>{
+        const reference = unqualifiedReference(part);
+        if (!CELL_OR_RANGE.test(reference) && !COLUMN_RANGE.test(reference) && !ROW_RANGE.test(reference)) return null;
+        return reference.replace(/[A-Z]+/gi, (column)=>column.toUpperCase());
+    });
+    return normalized.every((part)=>Boolean(part)) ? normalized.join(',') : null;
+}
+function normalizeSpreadsheetPrintTitleRows(value) {
+    const match = ROW_RANGE.exec(unqualifiedReference(value.trim().replace(/^=/, '')));
+    if (!match) return null;
+    const start = Number(match[1]);
+    const end = Number(match[2]);
+    return `$${Math.min(start, end)}:$${Math.max(start, end)}`;
+}
+function normalizeSpreadsheetPrintTitleColumns(value) {
+    const match = COLUMN_RANGE.exec(unqualifiedReference(value.trim().replace(/^=/, '')));
+    if (!match) return null;
+    const start = decodeColumn(match[1]);
+    const end = decodeColumn(match[2]);
+    return `$${encodeColumn(Math.min(start, end))}:$${encodeColumn(Math.max(start, end))}`;
+}
+function parseSpreadsheetPrintTitles(value) {
+    let rows;
+    let columns;
+    for (const part of splitRangeList(value.trim().replace(/^=/, ''))){
+        const rowReference = normalizeSpreadsheetPrintTitleRows(part);
+        if (rowReference) {
+            if (rows) return null;
+            const match = ROW_RANGE.exec(rowReference);
+            rows = [
+                Number(match[1]) - 1,
+                Number(match[2]) - 1
+            ];
+            continue;
+        }
+        const columnReference = normalizeSpreadsheetPrintTitleColumns(part);
+        if (!columnReference || columns) return null;
+        const match = COLUMN_RANGE.exec(columnReference);
+        columns = [
+            decodeColumn(match[1]),
+            decodeColumn(match[2])
+        ];
+    }
+    return rows || columns ? {
+        rows,
+        columns
+    } : null;
+}
+function parseSpreadsheetCellRanges(value) {
+    const parts = splitRangeList(value.trim().replace(/^=/, ''));
+    if (!parts.length) return null;
+    const ranges = parts.map((part)=>{
+        const cells = CELL_OR_RANGE.exec(unqualifiedReference(part));
+        if (!cells) return null;
+        const first = decodeCell(cells[1], cells[2]);
+        const second = cells[3] && cells[4] ? decodeCell(cells[3], cells[4]) : first;
+        return {
+            row: [
+                Math.min(first.row, second.row),
+                Math.max(first.row, second.row)
+            ],
+            column: [
+                Math.min(first.column, second.column),
+                Math.max(first.column, second.column)
+            ]
+        };
+    });
+    return ranges.every((range)=>Boolean(range)) ? ranges : null;
+}
+function formatSpreadsheetCellRanges(ranges) {
+    return ranges.map((range)=>{
+        const start = encodeCell(range.row[0], range.column[0]);
+        const end = encodeCell(range.row[1], range.column[1]);
+        return start === end ? start : `${start}:${end}`;
+    }).join(',');
+}
+function qualifySpreadsheetRange(value, sheetName) {
+    const prefix = `'${sheetName.replaceAll("'", "''")}'!`;
+    return splitRangeList(value).map((part)=>part.includes('!') ? part.trim() : `${prefix}${part.trim()}`).join(',');
+}
+function stripSpreadsheetSheetQualifier(value, sheetName) {
+    const quotedPrefix = `'${sheetName.replaceAll("'", "''")}'!`;
+    const plainPrefix = `${sheetName}!`;
+    return splitRangeList(value.trim().replace(/^=/, '')).map((part)=>{
+        const reference = part.trim();
+        if (reference.toLowerCase().startsWith(quotedPrefix.toLowerCase())) return reference.slice(quotedPrefix.length);
+        if (reference.toLowerCase().startsWith(plainPrefix.toLowerCase())) return reference.slice(plainPrefix.length);
+        return reference;
+    }).join(',');
+}
+function splitRangeList(value) {
+    const parts = [];
+    let current = '';
+    let quoted = false;
+    for(let index = 0; index < value.length; index += 1){
+        const character = value[index];
+        if ("'" === character) {
+            if (quoted && "'" === value[index + 1]) {
+                current += "''";
+                index += 1;
+                continue;
+            }
+            quoted = !quoted;
+        }
+        if (',' !== character || quoted) current += character;
+        else {
+            if (current.trim()) parts.push(current.trim());
+            current = '';
+        }
+    }
+    if (current.trim()) parts.push(current.trim());
+    return parts;
+}
+function unqualifiedReference(value) {
+    const reference = value.trim().replace(/^=/, '');
+    const separator = reference.lastIndexOf('!');
+    return separator >= 0 ? reference.slice(separator + 1) : reference;
+}
+function decodeCell(column, row) {
+    return {
+        row: Math.max(0, Number(row) - 1),
+        column: decodeColumn(column)
+    };
+}
+function decodeColumn(value) {
+    let result = 0;
+    for (const character of value.toUpperCase())result = 26 * result + character.charCodeAt(0) - 64;
+    return Math.max(0, result - 1);
+}
+function encodeCell(row, column) {
+    return `${encodeColumn(column)}${Math.max(0, row) + 1}`;
+}
+function encodeColumn(column) {
+    let value = Math.max(0, column) + 1;
+    let label = '';
+    while(value > 0){
+        value -= 1;
+        label = String.fromCharCode(65 + value % 26) + label;
+        value = Math.floor(value / 26);
+    }
+    return label;
+}
+function spreadsheetPivotCellValue(cell) {
+    return cell?.v ?? cell?.m ?? null;
+}
+function normalizeSpreadsheetPivotFilterValue(value) {
+    if (null == value || '' === value) return null;
+    if (value instanceof Date) return value.toISOString();
+    if ('number' == typeof value) return Number.isFinite(value) ? value : String(value);
+    if ('boolean' == typeof value) return value;
+    return String(value);
+}
+function spreadsheetPivotFilterValueKey(value) {
+    if (null === value) return 'blank:';
+    return `${typeof value}:${String(value)}`;
+}
+function displaySpreadsheetPivotValue(value) {
+    if (null == value || '' === value) return '(空白)';
+    if (value instanceof Date) return value.toISOString().slice(0, 10);
+    if ('boolean' == typeof value) return value ? 'TRUE' : 'FALSE';
+    return String(value);
+}
+function finiteSpreadsheetPivotNumber(value) {
+    if ('number' == typeof value) return Number.isFinite(value) ? value : null;
+    if (value instanceof Date) return value.getTime();
+    return null;
+}
+function spreadsheetPivotFilterItemsFromSource(sourceSheet, sourceBounds, fieldIndex) {
+    if (fieldIndex < 0 || fieldIndex > sourceBounds.endColumn - sourceBounds.startColumn) return [];
+    const items = new Map();
+    for(let row = sourceBounds.startRow + 1; row <= sourceBounds.endRow; row += 1){
+        const value = normalizeSpreadsheetPivotFilterValue(spreadsheetPivotCellValue(sourceSheet.data?.[row]?.[sourceBounds.startColumn + fieldIndex]));
+        const item = {
+            value,
+            label: displaySpreadsheetPivotValue(value)
+        };
+        items.set(spreadsheetPivotFilterValueKey(value), item);
+    }
+    return Array.from(items.values()).sort((left, right)=>left.label.localeCompare(right.label, 'zh-CN', {
+            numeric: true,
+            sensitivity: 'base'
+        }));
+}
+function buildSpreadsheetPivotOutput(sourceSheet, sourceBounds, fields, pivot) {
+    const rowCombinations = new Map();
+    const columnCombinations = new Map();
+    const cells = new Map();
+    const rowTotals = new Map();
+    const columnTotals = new Map();
+    const totals = pivot.values.map(()=>accumulator());
+    const singleColumn = combination([]);
+    if (!pivot.columnFields.length) columnCombinations.set(singleColumn.key, singleColumn);
+    for(let row = sourceBounds.startRow + 1; row <= sourceBounds.endRow; row += 1){
+        const values = fields.map((field)=>spreadsheetPivotCellValue(sourceSheet.data?.[row]?.[sourceBounds.startColumn + field.index]));
+        if (values.every((value)=>null == value || '' === value)) continue;
+        if (!matchesPivotReportFilters(values, pivot)) continue;
+        const rowCombination = combination(pivot.rowFields.map((fieldIndex)=>values[fieldIndex]));
+        const columnCombination = pivot.columnFields.length ? combination(pivot.columnFields.map((fieldIndex)=>values[fieldIndex])) : singleColumn;
+        rowCombinations.set(rowCombination.key, rowCombination);
+        columnCombinations.set(columnCombination.key, columnCombination);
+        for (const [valueIndex, valueField] of pivot.values.entries()){
+            const value = values[valueField.fieldIndex];
+            updateAccumulator(mapAccumulator(cells, cellKey(rowCombination.key, columnCombination.key, valueIndex)), value);
+            updateAccumulator(mapAccumulator(rowTotals, cellKey(rowCombination.key, '', valueIndex)), value);
+            updateAccumulator(mapAccumulator(columnTotals, cellKey('', columnCombination.key, valueIndex)), value);
+            updateAccumulator(totals[valueIndex], value);
+        }
+    }
+    const sortedRows = Array.from(rowCombinations.values()).sort(compareCombinations);
+    const sortedColumns = Array.from(columnCombinations.values()).sort(compareCombinations);
+    if (!sortedRows.length) return [];
+    const headers = [
+        ...pivot.rowFields.map((fieldIndex)=>fields[fieldIndex].name),
+        ...sortedColumns.flatMap((column)=>pivot.values.map((value)=>columnValueCaption(column, pivot.columnFields, fields, value))),
+        ...pivot.rowGrandTotals && pivot.columnFields.length ? pivot.values.map((value)=>`总计 · ${valueCaption(value, fields)}`) : []
+    ];
+    const output = [
+        headers.map((value)=>pivotHeaderCell(value))
+    ];
+    for (const row of sortedRows){
+        const result = row.values.map((value)=>pivotDimensionCell(value));
+        for (const column of sortedColumns)for (const [valueIndex, value] of pivot.values.entries())result.push(pivotValueCell(accumulatorValue(cells.get(cellKey(row.key, column.key, valueIndex)), value.aggregation), false));
+        if (pivot.rowGrandTotals && pivot.columnFields.length) for (const [valueIndex, value] of pivot.values.entries())result.push(pivotValueCell(accumulatorValue(rowTotals.get(cellKey(row.key, '', valueIndex)), value.aggregation), true));
+        output.push(result);
+    }
+    if (pivot.columnGrandTotals) {
+        const result = pivot.rowFields.map((_field, index)=>0 === index ? pivotTotalLabelCell() : pivotValueCell(null, true));
+        for (const column of sortedColumns)for (const [valueIndex, value] of pivot.values.entries())result.push(pivotValueCell(accumulatorValue(columnTotals.get(cellKey('', column.key, valueIndex)), value.aggregation), true));
+        if (pivot.rowGrandTotals && pivot.columnFields.length) for (const [valueIndex, value] of pivot.values.entries())result.push(pivotValueCell(accumulatorValue(totals[valueIndex], value.aggregation), true));
+        output.push(result);
+    }
+    const reportFilters = pivot.reportFilters ?? [];
+    if (!reportFilters.length) return output;
+    const width = output[0]?.length ?? 0;
+    const filterRows = reportFilters.map((filter)=>{
+        const row = Array(width).fill(null);
+        row[0] = pivotFilterLabelCell(fields[filter.fieldIndex].name);
+        row[1] = pivotFilterSelectionCell(void 0 === filter.selectedItem ? '(全部)' : displaySpreadsheetPivotValue(filter.selectedItem));
+        return row;
+    });
+    filterRows.push(Array(width).fill(null));
+    return [
+        ...filterRows,
+        ...output
+    ];
+}
+function accumulator() {
+    return {
+        nonEmptyCount: 0,
+        numberCount: 0,
+        sum: 0,
+        product: 1,
+        mean: 0,
+        m2: 0
+    };
+}
+function mapAccumulator(map, key) {
+    const existing = map.get(key);
+    if (existing) return existing;
+    const next = accumulator();
+    map.set(key, next);
+    return next;
+}
+function updateAccumulator(state, value) {
+    if (null != value && '' !== value) state.nonEmptyCount += 1;
+    const number = finiteSpreadsheetPivotNumber(value);
+    if (null === number) return;
+    state.numberCount += 1;
+    state.sum += number;
+    state.product *= number;
+    state.minimum = void 0 === state.minimum ? number : Math.min(state.minimum, number);
+    state.maximum = void 0 === state.maximum ? number : Math.max(state.maximum, number);
+    const delta = number - state.mean;
+    state.mean += delta / state.numberCount;
+    state.m2 += delta * (number - state.mean);
+}
+function accumulatorValue(state, aggregation) {
+    if (!state) return 'sum' === aggregation || 'count' === aggregation || 'counta' === aggregation ? 0 : null;
+    if ('count' === aggregation) return state.numberCount;
+    if ('counta' === aggregation) return state.nonEmptyCount;
+    if ('average' === aggregation) return state.numberCount ? state.sum / state.numberCount : null;
+    if ('max' === aggregation) return state.maximum ?? null;
+    if ('min' === aggregation) return state.minimum ?? null;
+    if ('product' === aggregation) return state.numberCount ? state.product : null;
+    if ('stdDev' === aggregation) return state.numberCount > 1 ? Math.sqrt(state.m2 / (state.numberCount - 1)) : null;
+    if ('stdDevP' === aggregation) return state.numberCount ? Math.sqrt(state.m2 / state.numberCount) : null;
+    if ('var' === aggregation) return state.numberCount > 1 ? state.m2 / (state.numberCount - 1) : null;
+    if ('varP' === aggregation) return state.numberCount ? state.m2 / state.numberCount : null;
+    return state.sum;
+}
+function combination(values) {
+    return {
+        key: JSON.stringify(values.map(normalizedPivotKeyValue)),
+        values
+    };
+}
+function normalizedPivotKeyValue(value) {
+    if (value instanceof Date) return [
+        'date',
+        value.toISOString()
+    ];
+    if ('number' == typeof value) return [
+        'number',
+        Number.isFinite(value) ? value : null
+    ];
+    if ('boolean' == typeof value) return [
+        'boolean',
+        value
+    ];
+    if (null == value || '' === value) return [
+        'blank'
+    ];
+    return [
+        'string',
+        String(value)
+    ];
+}
+function compareCombinations(left, right) {
+    const count = Math.max(left.values.length, right.values.length);
+    for(let index = 0; index < count; index += 1){
+        const difference = displaySpreadsheetPivotValue(left.values[index]).localeCompare(displaySpreadsheetPivotValue(right.values[index]), 'zh-CN', {
+            numeric: true,
+            sensitivity: 'base'
+        });
+        if (difference) return difference;
+    }
+    return 0;
+}
+function cellKey(rowKey, columnKey, valueIndex) {
+    return `${rowKey.length}:${rowKey}${columnKey.length}:${columnKey}${valueIndex}`;
+}
+function columnValueCaption(column, columnFields, fields, value) {
+    const dimensions = column.values.map((item, index)=>{
+        const label = displaySpreadsheetPivotValue(item);
+        return columnFields.length > 1 ? `${fields[columnFields[index]].name}: ${label}` : label;
+    });
+    return [
+        ...dimensions,
+        valueCaption(value, fields)
+    ].filter(Boolean).join(' · ');
+}
+function valueCaption(value, fields) {
+    return value.caption?.trim() || defaultPivotValueCaption(fields[value.fieldIndex]?.name ?? `字段 ${value.fieldIndex + 1}`, value.aggregation);
+}
+function defaultPivotValueCaption(fieldName, aggregation) {
+    return `${fieldName}（${spreadsheetPivotAggregationLabel(aggregation)}）`;
+}
+function spreadsheetPivotAggregationLabel(aggregation) {
+    if ('count' === aggregation) return '计数';
+    if ('counta' === aggregation) return '非空计数';
+    if ('average' === aggregation) return '平均值';
+    if ('max' === aggregation) return '最大值';
+    if ('min' === aggregation) return '最小值';
+    if ('product' === aggregation) return '乘积';
+    if ('stdDev' === aggregation) return '样本标准差';
+    if ('stdDevP' === aggregation) return '总体标准差';
+    if ('var' === aggregation) return '样本方差';
+    if ('varP' === aggregation) return '总体方差';
+    return '求和';
+}
+function pivotHeaderCell(value) {
+    return {
+        v: value,
+        m: value,
+        bl: 1,
+        bg: '#e7f1ec',
+        fc: '#173d2b'
+    };
+}
+function pivotDimensionCell(value) {
+    const display = displaySpreadsheetPivotValue(value);
+    return {
+        v: null == value || '' === value ? display : value,
+        m: display
+    };
+}
+function pivotValueCell(value, total) {
+    if (null === value) return total ? {
+        v: '',
+        m: '',
+        bl: 1,
+        bg: '#f3f7f5'
+    } : null;
+    return {
+        v: value,
+        m: formatPivotNumber(value),
+        bl: total ? 1 : void 0,
+        bg: total ? '#f3f7f5' : void 0,
+        ht: 2
+    };
+}
+function pivotTotalLabelCell() {
+    return {
+        v: '总计',
+        m: '总计',
+        bl: 1,
+        bg: '#f3f7f5'
+    };
+}
+function pivotFilterLabelCell(value) {
+    return {
+        v: value,
+        m: value,
+        bl: 1,
+        bg: '#f3f7f5',
+        fc: '#173d2b'
+    };
+}
+function pivotFilterSelectionCell(value) {
+    return {
+        v: value,
+        m: value,
+        bg: '#f3f7f5'
+    };
+}
+function formatPivotNumber(value) {
+    return Number.isInteger(value) ? String(value) : String(Number(value.toPrecision(15)));
+}
+function matchesPivotReportFilters(values, pivot) {
+    return (pivot.reportFilters ?? []).every((filter)=>void 0 === filter.selectedItem || spreadsheetPivotFilterValueKey(normalizeSpreadsheetPivotFilterValue(values[filter.fieldIndex])) === spreadsheetPivotFilterValueKey(filter.selectedItem));
+}
+const MAXIMUM_SOURCE_CELLS = 100000;
+const MAXIMUM_OUTPUT_CELLS = 20000;
+const MAXIMUM_XLSX_ROW = 1048575;
+const MAXIMUM_XLSX_COLUMN = 16383;
+function spreadsheetPivotCount(content) {
+    return content.sheets.reduce((count, sheet)=>count + (sheet.pivotTables?.length ?? 0), 0);
+}
+function spreadsheetPivotFields(content, pivot) {
+    const sourceSheet = content.sheets.find((sheet)=>sheet.id === pivot.sourceSheetId);
+    const range = singleRange(pivot.sourceReference);
+    if (!sourceSheet || !range) return [];
+    const fields = [];
+    for(let column = range.startColumn; column <= range.endColumn; column += 1){
+        const header = spreadsheetPivotCellValue(sourceSheet.data?.[range.startRow]?.[column]);
+        if (null == header || '' === String(header).trim()) return [];
+        const name = displaySpreadsheetPivotValue(header).trim();
+        let numeric = false;
+        for(let row = range.startRow + 1; row <= range.endRow; row += 1){
+            const value = spreadsheetPivotCellValue(sourceSheet.data?.[row]?.[column]);
+            if (null != value && '' !== value) {
+                if (null !== finiteSpreadsheetPivotNumber(value)) {
+                    numeric = true;
+                    break;
+                }
+            }
+        }
+        fields.push({
+            index: column - range.startColumn,
+            name,
+            numeric
+        });
+    }
+    return uniqueFieldNames(fields) ? fields : [];
+}
+function spreadsheetPivotFilterItems(content, pivot, fieldIndex) {
+    const sourceSheet = content.sheets.find((sheet)=>sheet.id === pivot.sourceSheetId);
+    const range = singleRange(pivot.sourceReference);
+    if (!sourceSheet || !range || fieldIndex < 0 || fieldIndex > range.endColumn - range.startColumn) return [];
+    return spreadsheetPivotFilterItemsFromSource(sourceSheet, range, fieldIndex);
+}
+function createSpreadsheetPivotFromSelection(content, sourceSheetId, selection) {
+    const sourceSheet = content.sheets.find((sheet)=>sheet.id === sourceSheetId);
+    const bounds = selectionBounds(selection);
+    if (!sourceSheet || !bounds || bounds.endRow <= bounds.startRow) return {
+        content,
+        error: '请选择包含标题行和至少一行数据的连续区域。'
+    };
+    if (spreadsheetPivotIntersects(sourceSheet, {
+        startRow: bounds.startRow,
+        endRow: bounds.endRow,
+        startColumn: bounds.startColumn,
+        endColumn: bounds.endColumn
+    }).length) return {
+        content,
+        error: '不能把现有数据透视表的输出区域作为新的透视表源。'
+    };
+    const sourceReference = formatSpreadsheetCellRanges([
+        {
+            row: [
+                bounds.startRow,
+                bounds.endRow
+            ],
+            column: [
+                bounds.startColumn,
+                bounds.endColumn
+            ]
+        }
+    ]);
+    const draftPivot = {
+        id: createWorkId('pivot'),
+        name: nextPivotName(content),
+        sourceSheetId,
+        sourceReference,
+        anchor: 'A1',
+        rowFields: [],
+        columnFields: [],
+        reportFilters: [],
+        values: [],
+        rowGrandTotals: true,
+        columnGrandTotals: true,
+        styleName: 'PivotStyleLight16',
+        refreshOnLoad: true
+    };
+    const fields = spreadsheetPivotFields(content, draftPivot);
+    if (!fields.length) return {
+        content,
+        error: '透视表源区域的标题必须非空且不重复。'
+    };
+    const valueField = fields.find((field)=>field.numeric) ?? fields.at(-1);
+    const dimensions = fields.filter((field)=>field.index !== valueField.index);
+    const rowField = dimensions[0] ?? fields.find((field)=>field.index !== valueField.index);
+    if (!rowField) return {
+        content,
+        error: '透视表至少需要一个分类字段和一个值字段。'
+    };
+    const columnField = dimensions.find((field)=>field.index !== rowField.index);
+    draftPivot.rowFields = [
+        rowField.index
+    ];
+    draftPivot.columnFields = columnField ? [
+        columnField.index
+    ] : [];
+    draftPivot.values = [
+        {
+            fieldIndex: valueField.index,
+            aggregation: valueField.numeric ? 'sum' : 'counta',
+            caption: defaultPivotValueCaption(valueField.name, valueField.numeric ? 'sum' : 'counta')
+        }
+    ];
+    const ownerSheetId = createWorkId('sheet');
+    const ownerSheet = {
+        id: ownerSheetId,
+        name: nextSheetName(content, '数据透视表'),
+        order: content.sheets.length,
+        status: 0,
+        row: 40,
+        column: 12,
+        data: Array.from({
+            length: 40
+        }, ()=>Array(12).fill(null)),
+        config: {},
+        pivotTables: [
+            draftPivot
+        ]
+    };
+    const withReport = {
+        ...content,
+        sheets: [
+            ...content.sheets,
+            ownerSheet
+        ]
+    };
+    const validation = spreadsheetPivotValidation(withReport, ownerSheetId, draftPivot);
+    if (!validation.valid) return {
+        content,
+        error: validation.message
+    };
+    const next = refreshSpreadsheetPivotTables(withReport);
+    return {
+        content: next,
+        ownerSheetId,
+        pivotId: draftPivot.id
+    };
+}
+function refreshSpreadsheetPivotTables(content) {
+    if (!spreadsheetPivotCount(content)) return content;
+    const sheets = content.sheets.map((sheet)=>({
+            ...sheet,
+            pivotTables: sheet.pivotTables?.map((pivot)=>({
+                    ...pivot,
+                    rowFields: [
+                        ...pivot.rowFields
+                    ],
+                    columnFields: [
+                        ...pivot.columnFields
+                    ],
+                    reportFilters: pivot.reportFilters?.map((filter)=>({
+                            ...filter
+                        })),
+                    values: pivot.values.map((value)=>({
+                            ...value
+                        }))
+                }))
+        }));
+    const next = {
+        ...content,
+        sheets
+    };
+    for (const ownerSheet of sheets){
+        if (!ownerSheet.pivotTables?.length || !ownerSheet.id) continue;
+        let data = ownerSheet.data;
+        let dataChanged = false;
+        for (const pivot of ownerSheet.pivotTables){
+            const resolved = resolvePivot(next, ownerSheet.id, pivot);
+            if (resolved) {
+                if (!dataChanged) {
+                    data = cloneCellMatrix(ownerSheet.data);
+                    ownerSheet.data = data;
+                    dataChanged = true;
+                }
+                clearRange(data, singleRange(pivot.outputReference ?? ''));
+                writePivotOutput(data, resolved.outputBounds, resolved.output);
+                pivot.outputReference = resolved.outputReference;
+                ownerSheet.row = Math.max(ownerSheet.row ?? 0, resolved.outputBounds.endRow + 1, data.length);
+                ownerSheet.column = Math.max(ownerSheet.column ?? 0, resolved.outputBounds.endColumn + 1);
+            }
+        }
+    }
+    return next;
+}
+function reconcileSpreadsheetPivots(content, changedSheets) {
+    const sourceById = new Map(content.sheets.flatMap((sheet)=>sheet.id ? [
+            [
+                sheet.id,
+                sheet
+            ]
+        ] : []));
+    const sheets = changedSheets.map((sheet)=>{
+        const source = sheet.id ? sourceById.get(sheet.id) : void 0;
+        return source?.pivotTables?.length ? {
+            ...sheet,
+            pivotTables: source.pivotTables
+        } : sheet;
+    });
+    return refreshSpreadsheetPivotTables({
+        ...content,
+        sheets
+    });
+}
+function deleteSpreadsheetPivotTable(content, ownerSheetId, pivotId) {
+    const sheets = content.sheets.map((sheet)=>{
+        if (sheet.id !== ownerSheetId) return sheet;
+        const pivot = sheet.pivotTables?.find((candidate)=>candidate.id === pivotId);
+        if (!pivot) return sheet;
+        const data = cloneCellMatrix(sheet.data);
+        clearRange(data, singleRange(pivot.outputReference ?? ''));
+        const pivotTables = (sheet.pivotTables ?? []).filter((candidate)=>candidate.id !== pivotId);
+        return {
+            ...sheet,
+            data,
+            pivotTables: pivotTables.length ? pivotTables : void 0
+        };
+    });
+    return {
+        ...content,
+        sheets
+    };
+}
+function spreadsheetPivotValidation(content, ownerSheetId, pivot) {
+    const failure = pivotFailure(content, ownerSheetId, pivot);
+    if (failure) return failure;
+    const resolved = resolvePivot(content, ownerSheetId, pivot);
+    return resolved ? {
+        valid: true,
+        outputReference: resolved.outputReference
+    } : {
+        valid: false,
+        code: 'pivot.invalid',
+        message: '无法根据当前字段和源数据生成透视表。'
+    };
+}
+function spreadsheetPivotOutputContains(sheet, row, column) {
+    return (sheet.pivotTables ?? []).some((pivot)=>{
+        const bounds = singleRange(pivot.outputReference ?? '');
+        return Boolean(bounds && containsCell(bounds, row, column));
+    });
+}
+function spreadsheetPivotIntersects(sheet, range) {
+    return (sheet.pivotTables ?? []).filter((pivot)=>{
+        const bounds = singleRange(pivot.outputReference ?? '');
+        return Boolean(bounds && rangesOverlap(bounds, range));
+    });
+}
+function resolvePivot(content, ownerSheetId, pivot) {
+    const failure = pivotFailure(content, ownerSheetId, pivot);
+    if (failure) return null;
+    const ownerSheet = content.sheets.find((sheet)=>sheet.id === ownerSheetId);
+    const sourceSheet = content.sheets.find((sheet)=>sheet.id === pivot.sourceSheetId);
+    const sourceBounds = singleRange(pivot.sourceReference);
+    const anchor = singleRange(pivot.anchor);
+    const fields = spreadsheetPivotFields(content, pivot);
+    const output = buildSpreadsheetPivotOutput(sourceSheet, sourceBounds, fields, pivot);
+    if (!output.length || !output[0]?.length) return null;
+    const outputBounds = {
+        startRow: anchor.startRow,
+        endRow: anchor.startRow + output.length - 1,
+        startColumn: anchor.startColumn,
+        endColumn: anchor.startColumn + output[0].length - 1
+    };
+    const outputReference = formatBounds(outputBounds);
+    if (output.length * output[0].length > MAXIMUM_OUTPUT_CELLS) return null;
+    if (outputBounds.endRow > MAXIMUM_XLSX_ROW || outputBounds.endColumn > MAXIMUM_XLSX_COLUMN) return null;
+    if (ownerSheet.id === sourceSheet.id && rangesOverlap(sourceBounds, outputBounds)) return null;
+    const oldOutput = singleRange(pivot.outputReference ?? '');
+    for (const other of ownerSheet.pivotTables ?? []){
+        if (other.id === pivot.id) continue;
+        const otherOutput = singleRange(other.outputReference ?? '');
+        if (otherOutput && rangesOverlap(otherOutput, outputBounds)) return null;
+    }
+    for(let row = outputBounds.startRow; row <= outputBounds.endRow; row += 1)for(let column = outputBounds.startColumn; column <= outputBounds.endColumn; column += 1)if (!(oldOutput && containsCell(oldOutput, row, column))) {
+        if (ownerSheet.data?.[row]?.[column]) return null;
+    }
+    return {
+        ownerSheet,
+        sourceSheet,
+        sourceBounds,
+        outputBounds,
+        outputReference,
+        fields,
+        output
+    };
+}
+function pivotFailure(content, ownerSheetId, pivot) {
+    const ownerSheet = content.sheets.find((sheet)=>sheet.id === ownerSheetId);
+    const sourceSheet = content.sheets.find((sheet)=>sheet.id === pivot.sourceSheetId);
+    if (!ownerSheet || !sourceSheet) return invalid('pivot.source-sheet-missing', '找不到透视表的源工作表或目标工作表。');
+    const sourceBounds = singleRange(pivot.sourceReference);
+    if (!sourceBounds || sourceBounds.endRow <= sourceBounds.startRow) return invalid('pivot.source-reference-invalid', '源区域必须是包含标题和数据的连续单元格范围。');
+    const sourceCellCount = (sourceBounds.endRow - sourceBounds.startRow + 1) * (sourceBounds.endColumn - sourceBounds.startColumn + 1);
+    if (sourceCellCount > MAXIMUM_SOURCE_CELLS) return invalid('pivot.source-too-large', `源区域不能超过 ${MAXIMUM_SOURCE_CELLS.toLocaleString()} 个单元格。`);
+    const anchor = singleRange(pivot.anchor);
+    if (!anchor || anchor.startRow !== anchor.endRow || anchor.startColumn !== anchor.endColumn) return invalid('pivot.anchor-invalid', '输出位置必须是一个 A1 单元格地址。');
+    const fields = spreadsheetPivotFields(content, pivot);
+    if (!fields.length) return invalid('pivot.headers-invalid', '源区域的标题必须非空且不重复。');
+    const reportFilters = pivot.reportFilters ?? [];
+    const reportFilterFields = reportFilters.map((filter)=>filter.fieldIndex);
+    if (new Set(reportFilterFields).size !== reportFilterFields.length || reportFilterFields.some((index)=>!fields[index]) || reportFilterFields.some((index)=>pivot.rowFields.includes(index) || pivot.columnFields.includes(index))) return invalid('pivot.filters-invalid', '报表筛选字段必须存在、互不重复，且不能同时作为行或列字段。');
+    for (const filter of reportFilters)if (void 0 !== filter.selectedItem && !spreadsheetPivotFilterItems(content, pivot, filter.fieldIndex).some((item)=>spreadsheetPivotFilterValueKey(item.value) === spreadsheetPivotFilterValueKey(filter.selectedItem))) return invalid('pivot.filter-item-invalid', '报表筛选器选择的项目已不在源数据中。');
+    const dimensionFields = [
+        ...pivot.rowFields,
+        ...pivot.columnFields,
+        ...reportFilterFields
+    ];
+    if (!pivot.rowFields.length) return invalid('pivot.rows-empty', '至少选择一个行字段。');
+    if (!pivot.values.length) return invalid('pivot.values-empty', '至少选择一个值字段。');
+    if (new Set(dimensionFields).size !== dimensionFields.length || dimensionFields.some((index)=>!fields[index]) || pivot.values.some((value)=>!fields[value.fieldIndex])) return invalid('pivot.fields-invalid', '透视表包含重复、缺失或超出源区域的字段。');
+    const output = buildSpreadsheetPivotOutput(sourceSheet, sourceBounds, fields, pivot);
+    if (!output.length || !output[0]?.length) return invalid('pivot.output-empty', '当前源数据不能生成透视表结果。');
+    if (output.length * output[0].length > MAXIMUM_OUTPUT_CELLS) return invalid('pivot.output-too-large', `透视表结果不能超过 ${MAXIMUM_OUTPUT_CELLS.toLocaleString()} 个单元格。`);
+    const outputBounds = {
+        startRow: anchor.startRow,
+        endRow: anchor.startRow + output.length - 1,
+        startColumn: anchor.startColumn,
+        endColumn: anchor.startColumn + output[0].length - 1
+    };
+    if (outputBounds.endRow > MAXIMUM_XLSX_ROW || outputBounds.endColumn > MAXIMUM_XLSX_COLUMN) return invalid('pivot.output-out-of-bounds', '透视表结果超出 XLSX 工作表边界。');
+    if (ownerSheet.id === sourceSheet.id && rangesOverlap(sourceBounds, outputBounds)) return invalid('pivot.output-overlaps-source', '透视表输出区域与源数据重叠，请改用其他位置或工作表。');
+    if (Object.values(ownerSheet.config?.merge ?? {}).some((merge)=>rangesOverlap(outputBounds, {
+            startRow: merge.r,
+            endRow: merge.r + merge.rs - 1,
+            startColumn: merge.c,
+            endColumn: merge.c + merge.cs - 1
+        }))) return invalid('pivot.output-overlaps-merge', '透视表输出区域与合并单元格重叠。');
+    const oldOutput = singleRange(pivot.outputReference ?? '');
+    for (const other of ownerSheet.pivotTables ?? []){
+        if (other.id === pivot.id) continue;
+        const otherOutput = singleRange(other.outputReference ?? '');
+        if (otherOutput && rangesOverlap(otherOutput, outputBounds)) return invalid('pivot.output-overlaps-pivot', '透视表输出区域与另一个透视表重叠。');
+    }
+    for(let row = outputBounds.startRow; row <= outputBounds.endRow; row += 1)for(let column = outputBounds.startColumn; column <= outputBounds.endColumn; column += 1)if (!(oldOutput && containsCell(oldOutput, row, column))) {
+        if (ownerSheet.data?.[row]?.[column]) return invalid('pivot.output-not-empty', '透视表输出区域包含现有内容，请选择空白位置。');
+    }
+    return null;
+}
+function uniqueFieldNames(fields) {
+    const names = fields.map((field)=>field.name.trim().toLocaleLowerCase());
+    return names.every(Boolean) && new Set(names).size === names.length;
+}
+function singleRange(reference) {
+    const ranges = parseSpreadsheetCellRanges(reference);
+    if (ranges?.length !== 1) return null;
+    return {
+        startRow: ranges[0].row[0],
+        endRow: ranges[0].row[1],
+        startColumn: ranges[0].column[0],
+        endColumn: ranges[0].column[1]
+    };
+}
+function selectionBounds(selection) {
+    if (selection.row.length < 2 || selection.column.length < 2) return null;
+    return {
+        startRow: Math.max(0, Math.min(selection.row[0], selection.row[1])),
+        endRow: Math.max(0, Math.max(selection.row[0], selection.row[1])),
+        startColumn: Math.max(0, Math.min(selection.column[0], selection.column[1])),
+        endColumn: Math.max(0, Math.max(selection.column[0], selection.column[1]))
+    };
+}
+function containsCell(bounds, row, column) {
+    return row >= bounds.startRow && row <= bounds.endRow && column >= bounds.startColumn && column <= bounds.endColumn;
+}
+function rangesOverlap(left, right) {
+    return left.startRow <= right.endRow && left.endRow >= right.startRow && left.startColumn <= right.endColumn && left.endColumn >= right.startColumn;
+}
+function formatBounds(bounds) {
+    return formatSpreadsheetCellRanges([
+        {
+            row: [
+                bounds.startRow,
+                bounds.endRow
+            ],
+            column: [
+                bounds.startColumn,
+                bounds.endColumn
+            ]
+        }
+    ]);
+}
+function cloneCellMatrix(source) {
+    return (source ?? []).map((row)=>[
+            ...row
+        ]);
+}
+function clearRange(data, bounds) {
+    if (!bounds) return;
+    for(let row = bounds.startRow; row <= bounds.endRow; row += 1)if (data[row]) for(let column = bounds.startColumn; column <= bounds.endColumn; column += 1)data[row][column] = null;
+}
+function writePivotOutput(data, bounds, output) {
+    const width = output[0]?.length ?? 0;
+    while(data.length <= bounds.endRow)data.push([]);
+    for(let row = 0; row < output.length; row += 1){
+        const target = data[bounds.startRow + row] ?? [];
+        data[bounds.startRow + row] = target;
+        while(target.length < bounds.startColumn + width)target.push(null);
+        for(let column = 0; column < width; column += 1)target[bounds.startColumn + column] = output[row][column] ?? null;
+    }
+}
+function nextSheetName(content, base) {
+    const existing = new Set(content.sheets.map((sheet)=>sheet.name.toLocaleLowerCase()));
+    if (!existing.has(base.toLocaleLowerCase())) return base;
+    let index = 2;
+    while(existing.has(`${base} ${index}`.toLocaleLowerCase()))index += 1;
+    return `${base} ${index}`;
+}
+function nextPivotName(content) {
+    const existing = new Set(content.sheets.flatMap((sheet)=>(sheet.pivotTables ?? []).map((pivot)=>pivot.name.toLocaleLowerCase())));
+    let index = 1;
+    while(existing.has(`pivottable${index}`))index += 1;
+    return `PivotTable${index}`;
+}
+function invalid(code, message) {
+    return {
+        valid: false,
+        code,
+        message
+    };
+}
+class OoxmlPackage {
+    zip;
+    constructor(zip){
+        this.zip = zip;
+    }
+    static async load(buffer) {
+        return new OoxmlPackage(await jszip.loadAsync(buffer));
+    }
+    has(partPath) {
+        return Boolean(this.zip.file(partPath));
+    }
+    paths(prefix) {
+        return Object.keys(this.zip.files).filter((path)=>path.startsWith(prefix) && !this.zip.files[path]?.dir);
+    }
+    async text(partPath) {
+        const entry = this.zip.file(partPath);
+        if (!entry) throw new Error(`Office package part is missing: ${partPath}`);
+        return entry.async('text');
+    }
+    async xml(partPath) {
+        return parseXml(await this.text(partPath), partPath);
+    }
+    async bytes(partPath) {
+        const entry = this.zip.file(partPath);
+        if (!entry) throw new Error(`Office package part is missing: ${partPath}`);
+        return entry.async('uint8array');
+    }
+    async relationships(sourcePart) {
+        const partPath = relationshipsPartPath(sourcePart);
+        if (!this.has(partPath)) return new Map();
+        const document = await this.xml(partPath);
+        return new Map(descendants(document, 'Relationship').map((element)=>{
+            const relationship = {
+                id: attribute(element, 'Id') ?? '',
+                target: resolvePartTarget(sourcePart, attribute(element, 'Target') ?? ''),
+                type: attribute(element, 'Type') ?? '',
+                targetMode: attribute(element, 'TargetMode') ?? void 0
+            };
+            return [
+                relationship.id,
+                relationship
+            ];
+        }));
+    }
+}
+function parseXml(source, label = 'Office XML') {
+    const document = new DOMParser().parseFromString(source, 'application/xml');
+    const error = descendants(document, 'parsererror')[0];
+    if (error) throw new Error(`${label} is not valid XML: ${error.textContent?.trim() || 'parse error'}`);
+    return document;
+}
+function attribute(element, name) {
+    const direct = element.getAttribute(name);
+    if (null !== direct) return direct;
+    const localName = name.includes(':') ? name.slice(name.indexOf(':') + 1) : name;
+    return Array.from(element.attributes).find((item)=>{
+        const itemLocalName = item.localName.includes(':') ? item.localName.slice(item.localName.indexOf(':') + 1) : item.localName;
+        return itemLocalName === localName && (!name.includes(':') || item.name === name);
+    })?.value ?? null;
+}
+function xmlNamespacePrefix(element, namespace) {
+    if (!namespace) return element.prefix;
+    if ('function' == typeof element.lookupPrefix) {
+        const prefix = element.lookupPrefix(namespace);
+        if (prefix) return prefix;
+    }
+    let current = element;
+    while(current){
+        if (current.namespaceURI === namespace && current.prefix) return current.prefix;
+        const declaration = Array.from(current.attributes).find((item)=>item.value === namespace && ('xmlns' === item.name || item.name.startsWith('xmlns:')));
+        if (declaration?.name.startsWith('xmlns:')) return declaration.name.slice(6);
+        current = current.parentElement;
+    }
+    return null;
+}
+function directChildren(parent, localName) {
+    return Array.from(parent.children).filter((element)=>!localName || element.localName === localName);
+}
+function directChild(parent, localName) {
+    return directChildren(parent, localName)[0];
+}
+function descendants(parent, localName) {
+    return Array.from(parent.querySelectorAll('*')).filter((element)=>element.localName === localName);
+}
+function firstDescendant(parent, localName) {
+    if (!parent) return;
+    return descendants(parent, localName)[0];
+}
+function childPath(parent, ...localNames) {
+    let current = parent;
+    for (const name of localNames){
+        if (!current) return;
+        current = directChild(current, name);
+    }
+    return current instanceof Element ? current : void 0;
+}
+function resolvePartTarget(sourcePart, target) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(target)) return target;
+    const segments = target.startsWith('/') ? [] : sourcePart.split('/').slice(0, -1);
+    for (const segment of target.replace(/^\/+/, '').split('/'))if (segment && '.' !== segment) if ('..' === segment) segments.pop();
+    else segments.push(segment);
+    return segments.join('/');
+}
+function contentTypeForPart(partPath) {
+    const extension = partPath.split('.').pop()?.toLowerCase();
+    const types = {
+        apng: 'image/apng',
+        bmp: 'image/bmp',
+        emf: 'image/emf',
+        gif: 'image/gif',
+        jpeg: 'image/jpeg',
+        jpg: 'image/jpeg',
+        png: 'image/png',
+        svg: 'image/svg+xml',
+        tif: 'image/tiff',
+        tiff: 'image/tiff',
+        webp: 'image/webp',
+        wmf: 'image/wmf'
+    };
+    return types[extension ?? ''] ?? 'application/octet-stream';
+}
+function bytesToDataUrl(bytes, contentType) {
+    let binary = '';
+    const chunkSize = 32768;
+    for(let offset = 0; offset < bytes.length; offset += chunkSize)binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+    return `data:${contentType};base64,${btoa(binary)}`;
+}
+function relationshipsPartPath(sourcePart) {
+    const separator = sourcePart.lastIndexOf('/');
+    const directory = separator >= 0 ? sourcePart.slice(0, separator + 1) : '';
+    const fileName = separator >= 0 ? sourcePart.slice(separator + 1) : sourcePart;
+    return `${directory}_rels/${fileName}.rels`;
+}
+const WORK_SPREADSHEET_CHART_COLORS = [
+    '#4f6bed',
+    '#e66c37',
+    '#8f95a3',
+    '#f4b41a',
+    '#36a2ae',
+    '#6a9f4e'
+];
+function finiteChartNumber(value) {
+    return Number.isFinite(value) ? value : 0;
+}
+function compactChartNumber(value) {
+    const absolute = Math.abs(value);
+    if (absolute >= 1000000) return `${roundChartNumber(value / 1000000)}M`;
+    if (absolute >= 1000) return `${roundChartNumber(value / 1000)}K`;
+    return String(roundChartNumber(value));
+}
+function truncateChartText(value, length) {
+    const text = String(value);
+    return text.length > length ? `${text.slice(0, length - 1)}…` : text;
+}
+function roundChartNumber(value) {
+    return Math.round(100 * value) / 100;
+}
+function escapeChartXml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+}
+function normalizeWorkSpreadsheetChartLegendPosition(value) {
+    return 'left' === value || 'top' === value || 'bottom' === value || 'topRight' === value || 'right' === value ? value : 'right';
+}
+function normalizeWorkSpreadsheetChartLegendOverlay(value) {
+    return true === value;
+}
+function workSpreadsheetChartSupportsGrouping(type) {
+    return 'column' === type || 'bar' === type || 'line' === type || 'area' === type;
+}
+function workSpreadsheetChartSupportsBarSpacing(type) {
+    return 'column' === type || 'bar' === type;
+}
+function workSpreadsheetChartSupportsSmoothLines(type) {
+    return 'line' === type;
+}
+function workSpreadsheetChartDefaultGrouping(type) {
+    return workSpreadsheetChartSupportsBarSpacing(type) ? 'clustered' : 'standard';
+}
+function normalizeWorkSpreadsheetChartGrouping(value, type) {
+    const fallback = workSpreadsheetChartDefaultGrouping(type);
+    if (!workSpreadsheetChartSupportsGrouping(type)) return fallback;
+    if ('stacked' === value || 'percentStacked' === value) return value;
+    if (workSpreadsheetChartSupportsBarSpacing(type)) return 'standard' === value || 'clustered' === value ? value : fallback;
+    return 'standard' === value ? value : fallback;
+}
+function workSpreadsheetChartGroupingIsStacked(grouping) {
+    return 'stacked' === grouping || 'percentStacked' === grouping;
+}
+function normalizeWorkSpreadsheetChartGapWidth(value) {
+    return work_spreadsheet_chart_layout_normalizedInteger(value, 0, 500, 150);
+}
+function normalizeWorkSpreadsheetChartOverlap(value, grouping) {
+    return work_spreadsheet_chart_layout_normalizedInteger(value, -100, 100, workSpreadsheetChartGroupingIsStacked(grouping) ? 100 : 0);
+}
+function normalizeWorkSpreadsheetChartSmoothLines(value) {
+    return true === value;
+}
+function normalizeWorkSpreadsheetChartLayout(source) {
+    const grouping = normalizeWorkSpreadsheetChartGrouping(source.grouping, source.type);
+    return {
+        legendPosition: normalizeWorkSpreadsheetChartLegendPosition(source.legendPosition),
+        legendOverlay: normalizeWorkSpreadsheetChartLegendOverlay(source.legendOverlay),
+        grouping: workSpreadsheetChartSupportsGrouping(source.type) ? grouping : void 0,
+        gapWidth: workSpreadsheetChartSupportsBarSpacing(source.type) ? normalizeWorkSpreadsheetChartGapWidth(source.gapWidth) : void 0,
+        overlap: workSpreadsheetChartSupportsBarSpacing(source.type) ? normalizeWorkSpreadsheetChartOverlap(source.overlap, grouping) : void 0,
+        smoothLines: workSpreadsheetChartSupportsSmoothLines(source.type) ? normalizeWorkSpreadsheetChartSmoothLines(source.smoothLines) : void 0
+    };
+}
+function workSpreadsheetChartSupportsSeriesAnalysis(source) {
+    if (!workSpreadsheetChartSupportsGrouping(source.type)) return true;
+    return !workSpreadsheetChartGroupingIsStacked(normalizeWorkSpreadsheetChartGrouping(source.grouping, source.type));
+}
+function workSpreadsheetChartLegendPositionLabel(position) {
+    if ('left' === position) return '左侧';
+    if ('top' === position) return '顶部';
+    if ('bottom' === position) return '底部';
+    if ('topRight' === position) return '右上角';
+    return '右侧';
+}
+function workSpreadsheetChartGroupingLabel(grouping) {
+    if ('stacked' === grouping) return '堆积';
+    if ('percentStacked' === grouping) return '百分比堆积';
+    if ('standard' === grouping) return '标准';
+    return '簇状';
+}
+function work_spreadsheet_chart_layout_normalizedInteger(value, minimum, maximum, fallback) {
+    if (null == value || '' === value) return fallback;
+    const number = Number(value);
+    if (!Number.isFinite(number)) return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.round(number)));
+}
+const LINE_DASHES = new Set([
+    'solid',
+    'dash',
+    'dot',
+    'dashDot'
+]);
+const MARKER_SYMBOLS = new Set([
+    'none',
+    'circle',
+    'square',
+    'diamond',
+    'triangle',
+    'plus',
+    'x',
+    'star'
+]);
+function normalizeWorkSpreadsheetChartSeriesStyle(source) {
+    if (!source || 'object' != typeof source) return;
+    const fillColor = normalizeWorkSpreadsheetChartColor(source.fillColor);
+    const fillTransparency = optionalBoundedNumber(source.fillTransparency, 0, 100, 0);
+    const lineColor = normalizeWorkSpreadsheetChartColor(source.lineColor);
+    const lineWidth = optionalBoundedNumber(source.lineWidth, 0.25, 20, 2.25);
+    const lineDash = LINE_DASHES.has(source.lineDash) ? source.lineDash : void 0;
+    const marker = normalizeWorkSpreadsheetChartMarkerStyle(source.marker);
+    const normalized = {
+        ...fillColor ? {
+            fillColor
+        } : {},
+        ...void 0 !== fillTransparency ? {
+            fillTransparency
+        } : {},
+        ...lineColor ? {
+            lineColor
+        } : {},
+        ...void 0 !== lineWidth ? {
+            lineWidth
+        } : {},
+        ...lineDash ? {
+            lineDash
+        } : {},
+        ...marker ? {
+            marker
+        } : {}
+    };
+    return Object.keys(normalized).length ? normalized : void 0;
+}
+function normalizeWorkSpreadsheetChartColor(value) {
+    if ('string' != typeof value) return;
+    const text = value.trim().replace(/^#/, '');
+    if (/^[0-9a-f]{3}$/i.test(text)) return `#${text.split('').map((character)=>character.repeat(2)).join('')}`.toUpperCase();
+    return /^[0-9a-f]{6}$/i.test(text) ? `#${text.toUpperCase()}` : void 0;
+}
+function defaultWorkSpreadsheetChartSeriesStyle(seriesIndex) {
+    const color = workSpreadsheetChartSeriesDefaultColor(seriesIndex);
+    return {
+        fillColor: color,
+        fillTransparency: 0,
+        lineColor: color,
+        lineWidth: 2.5,
+        lineDash: 'solid',
+        marker: {
+            symbol: 'circle',
+            size: 5,
+            fillColor: '#FFFFFF',
+            lineColor: color
+        }
+    };
+}
+function workSpreadsheetChartSeriesDefaultColor(seriesIndex) {
+    return WORK_SPREADSHEET_CHART_COLORS[seriesIndex % WORK_SPREADSHEET_CHART_COLORS.length].toUpperCase();
+}
+function spreadsheetChartSeriesFillStyle(series, seriesIndex, defaultOpacity = 1, defaultColor = workSpreadsheetChartSeriesDefaultColor(seriesIndex)) {
+    const style = normalizeWorkSpreadsheetChartSeriesStyle(series.style);
+    const color = style?.fillColor ?? defaultColor;
+    const opacity = style?.fillTransparency === void 0 ? boundedNumber(defaultOpacity, 0, 1, 1) : 1 - style.fillTransparency / 100;
+    return {
+        color,
+        opacity,
+        attributes: `fill="${escapeChartXml(color)}"${opacity < 1 ? ` fill-opacity="${compactDecimal(opacity)}"` : ''}`
+    };
+}
+function spreadsheetChartSeriesLineStyle(series, seriesIndex, defaultWidth, defaultColor = workSpreadsheetChartSeriesDefaultColor(seriesIndex)) {
+    const style = normalizeWorkSpreadsheetChartSeriesStyle(series.style);
+    const hasCustomLine = Boolean(style?.lineColor || style?.lineWidth !== void 0 || style?.lineDash);
+    const color = style?.lineColor ?? defaultColor;
+    const width = style?.lineWidth ?? (hasCustomLine && defaultWidth <= 0 ? 1 : defaultWidth);
+    const dash = style?.lineDash ?? 'solid';
+    const dashArray = spreadsheetChartLineDashArray(dash);
+    return {
+        color,
+        width,
+        dash,
+        attributes: !hasCustomLine && defaultWidth <= 0 ? 'stroke="none"' : `stroke="${escapeChartXml(color)}" stroke-width="${compactDecimal(width)}"${dashArray ? ` stroke-dasharray="${dashArray}"` : ''}`
+    };
+}
+function spreadsheetChartSeriesLegendColor(series, seriesIndex) {
+    const style = normalizeWorkSpreadsheetChartSeriesStyle(series.style);
+    return style?.fillColor ?? style?.lineColor ?? workSpreadsheetChartSeriesDefaultColor(seriesIndex);
+}
+function spreadsheetChartSeriesMarkerSvg(series, seriesIndex, x, y, options) {
+    const style = normalizeWorkSpreadsheetChartSeriesStyle(series.style);
+    const marker = style?.marker;
+    const visible = marker ? 'none' !== marker.symbol : options.visible;
+    if (!visible) return '';
+    const symbol = marker?.symbol && 'none' !== marker.symbol ? marker.symbol : 'circle';
+    const size = marker?.size ?? options.defaultSize ?? 5;
+    const radius = Math.max(1, 0.6 * size);
+    const line = spreadsheetChartSeriesLineStyle(series, seriesIndex, 2);
+    const fillColor = marker?.fillColor ?? '#FFFFFF';
+    const lineColor = marker?.lineColor ?? line.color;
+    const common = `data-marker-symbol="${symbol}" data-marker-size="${compactDecimal(size)}"${options.attributes ? ` ${options.attributes}` : ''}`;
+    const paint = `fill="${escapeChartXml(fillColor)}" stroke="${escapeChartXml(lineColor)}" stroke-width="2"`;
+    const pointX = roundChartNumber(x);
+    const pointY = roundChartNumber(y);
+    if ('square' === symbol) {
+        const side = 1.7 * radius;
+        return `<rect ${common} x="${roundChartNumber(x - side / 2)}" y="${roundChartNumber(y - side / 2)}" width="${roundChartNumber(side)}" height="${roundChartNumber(side)}" rx="0.6" ${paint}/>`;
+    }
+    if ('diamond' === symbol) return `<path ${common} d="M ${pointX} ${roundChartNumber(y - radius)} L ${roundChartNumber(x + radius)} ${pointY} L ${pointX} ${roundChartNumber(y + radius)} L ${roundChartNumber(x - radius)} ${pointY} Z" ${paint}/>`;
+    if ('triangle' === symbol) return `<path ${common} d="M ${pointX} ${roundChartNumber(y - radius)} L ${roundChartNumber(x + 0.9 * radius)} ${roundChartNumber(y + 0.75 * radius)} L ${roundChartNumber(x - 0.9 * radius)} ${roundChartNumber(y + 0.75 * radius)} Z" ${paint}/>`;
+    if ('plus' === symbol || 'x' === symbol) {
+        const paths = 'plus' === symbol ? `M ${roundChartNumber(x - radius)} ${pointY} L ${roundChartNumber(x + radius)} ${pointY} M ${pointX} ${roundChartNumber(y - radius)} L ${pointX} ${roundChartNumber(y + radius)}` : `M ${roundChartNumber(x - radius)} ${roundChartNumber(y - radius)} L ${roundChartNumber(x + radius)} ${roundChartNumber(y + radius)} M ${roundChartNumber(x + radius)} ${roundChartNumber(y - radius)} L ${roundChartNumber(x - radius)} ${roundChartNumber(y + radius)}`;
+        return `<path ${common} d="${paths}" fill="none" stroke="${escapeChartXml(lineColor)}" stroke-width="2" stroke-linecap="round"/>`;
+    }
+    if ('star' === symbol) {
+        const points = Array.from({
+            length: 10
+        }, (_, index)=>{
+            const angle = -Math.PI / 2 + index * Math.PI / 5;
+            const pointRadius = index % 2 ? 0.42 * radius : radius;
+            return `${roundChartNumber(x + Math.cos(angle) * pointRadius)},${roundChartNumber(y + Math.sin(angle) * pointRadius)}`;
+        }).join(' ');
+        return `<polygon ${common} points="${points}" ${paint}/>`;
+    }
+    return `<circle ${common} cx="${pointX}" cy="${pointY}" r="${roundChartNumber(radius)}" ${paint}/>`;
+}
+function spreadsheetChartSeriesStyleContext(style) {
+    const normalized = normalizeWorkSpreadsheetChartSeriesStyle(style);
+    if (!normalized) return '';
+    const descriptions = [];
+    if (normalized.fillColor || void 0 !== normalized.fillTransparency) descriptions.push(`填充 ${normalized.fillColor ?? '默认颜色'}${void 0 === normalized.fillTransparency ? '' : `（透明度 ${compactDecimal(normalized.fillTransparency)}%）`}`);
+    if (normalized.lineColor || void 0 !== normalized.lineWidth || normalized.lineDash) descriptions.push([
+        `线条 ${normalized.lineColor ?? '默认颜色'}`,
+        void 0 === normalized.lineWidth ? '' : `${compactDecimal(normalized.lineWidth)} 磅`,
+        normalized.lineDash ? workSpreadsheetChartLineDashLabel(normalized.lineDash) : ''
+    ].filter(Boolean).join('、'));
+    if (normalized.marker) {
+        const marker = normalized.marker;
+        descriptions.push([
+            `数据标记 ${workSpreadsheetChartMarkerSymbolLabel(marker.symbol ?? 'circle')}`,
+            void 0 === marker.size ? '' : `${compactDecimal(marker.size)} 磅`,
+            marker.fillColor ? `填充 ${marker.fillColor}` : '',
+            marker.lineColor ? `轮廓 ${marker.lineColor}` : ''
+        ].filter(Boolean).join('、'));
+    }
+    return descriptions.length ? `；系列外观：${descriptions.join('，')}` : '';
+}
+function workSpreadsheetChartLineDashLabel(dash) {
+    if ('dash' === dash) return '虚线';
+    if ('dot' === dash) return '点线';
+    if ('dashDot' === dash) return '点划线';
+    return '实线';
+}
+function workSpreadsheetChartMarkerSymbolLabel(symbol) {
+    if ('none' === symbol) return '无';
+    if ('square' === symbol) return '方形';
+    if ('diamond' === symbol) return '菱形';
+    if ('triangle' === symbol) return '三角形';
+    if ('plus' === symbol) return '加号';
+    if ('x' === symbol) return '叉号';
+    if ('star' === symbol) return '星形';
+    return '圆形';
+}
+function normalizeWorkSpreadsheetChartMarkerStyle(value) {
+    if (!value || 'object' != typeof value) return;
+    const source = value;
+    const symbol = MARKER_SYMBOLS.has(source.symbol) ? source.symbol : void 0;
+    const size = optionalBoundedNumber(source.size, 2, 72, 5);
+    const fillColor = normalizeWorkSpreadsheetChartColor(source.fillColor);
+    const lineColor = normalizeWorkSpreadsheetChartColor(source.lineColor);
+    const marker = {
+        ...symbol ? {
+            symbol
+        } : {},
+        ...void 0 !== size ? {
+            size
+        } : {},
+        ...fillColor ? {
+            fillColor
+        } : {},
+        ...lineColor ? {
+            lineColor
+        } : {}
+    };
+    return Object.keys(marker).length ? marker : void 0;
+}
+function spreadsheetChartLineDashArray(dash) {
+    if ('dash' === dash) return '8 4';
+    if ('dot' === dash) return '2 3';
+    if ('dashDot' === dash) return '8 4 2 4';
+    return '';
+}
+function optionalBoundedNumber(value, minimum, maximum, fallback) {
+    if (null == value || '' === value) return;
+    const number = Number(value);
+    return boundedNumber(number, minimum, maximum, fallback);
+}
+function boundedNumber(value, minimum, maximum, fallback) {
+    return Math.min(maximum, Math.max(minimum, Number.isFinite(value) ? value : fallback));
+}
+function compactDecimal(value) {
+    return String(Math.round(100 * value) / 100);
+}
+const VERTICAL_RESERVE = 118;
+const HORIZONTAL_RESERVE = 40;
+function spreadsheetChartLegendLayout(chart, sourcePlot, frame) {
+    if (!chart.showLegend) return {
+        plot: sourcePlot,
+        svg: ''
+    };
+    const position = normalizeWorkSpreadsheetChartLegendPosition(chart.legendPosition);
+    const overlay = normalizeWorkSpreadsheetChartLegendOverlay(chart.legendOverlay);
+    const plot = reservedPlot(sourcePlot, position, overlay);
+    const bounds = legendBounds(sourcePlot, plot, frame, position, overlay);
+    const items = spreadsheetChartLegendItems(chart).slice(0, 8);
+    const entries = 'top' === position || 'bottom' === position ? horizontalLegendEntries(items, bounds) : verticalLegendEntries(items, bounds);
+    return {
+        plot,
+        svg: `<g data-chart-legend-position="${position}" data-chart-legend-overlay="${overlay}" aria-label="图例">${entries}</g>`
+    };
+}
+function reservedPlot(source, position, overlay) {
+    if (overlay) return source;
+    if ('left' === position) return {
+        ...source,
+        x: source.x + VERTICAL_RESERVE,
+        width: Math.max(40, source.width - VERTICAL_RESERVE)
+    };
+    if ('right' === position || 'topRight' === position) return {
+        ...source,
+        width: Math.max(40, source.width - VERTICAL_RESERVE)
+    };
+    if ('top' === position) return {
+        ...source,
+        y: source.y + HORIZONTAL_RESERVE,
+        height: Math.max(40, source.height - HORIZONTAL_RESERVE)
+    };
+    return {
+        ...source,
+        height: Math.max(40, source.height - HORIZONTAL_RESERVE)
+    };
+}
+function legendBounds(source, plot, frame, position, overlay) {
+    if ('left' === position) return {
+        x: 12,
+        y: frame.titleHeight + 18,
+        width: VERTICAL_RESERVE - 18,
+        height: frame.height - frame.titleHeight - 32
+    };
+    if ('right' === position || 'topRight' === position) return {
+        x: overlay ? source.x + source.width - VERTICAL_RESERVE + 12 : plot.x + plot.width + 12,
+        y: 'topRight' === position ? frame.titleHeight + 4 : frame.titleHeight + 18,
+        width: VERTICAL_RESERVE - 18,
+        height: frame.height - frame.titleHeight - 32
+    };
+    if ('top' === position) return {
+        x: plot.x,
+        y: frame.titleHeight + 4,
+        width: plot.width,
+        height: HORIZONTAL_RESERVE - 4
+    };
+    return {
+        x: plot.x,
+        y: frame.height - HORIZONTAL_RESERVE + 6,
+        width: plot.width,
+        height: HORIZONTAL_RESERVE - 8
+    };
+}
+function spreadsheetChartLegendItems(chart) {
+    if ('pie' === chart.type || 'doughnut' === chart.type) {
+        const values = chart.series[0]?.values ?? [];
+        const seriesColor = normalizeWorkSpreadsheetChartSeriesStyle(chart.series[0]?.style)?.fillColor;
+        return chart.categories.map((category, index)=>({
+                color: seriesColor ?? WORK_SPREADSHEET_CHART_COLORS[index % WORK_SPREADSHEET_CHART_COLORS.length],
+                label: `${category}${void 0 === values[index] ? '' : ` ${compactChartNumber(values[index])}`}`
+            }));
+    }
+    return chart.series.map((series, index)=>({
+            color: spreadsheetChartSeriesLegendColor(series, index),
+            label: series.name || `系列 ${index + 1}`
+        }));
+}
+function verticalLegendEntries(items, bounds) {
+    return items.map((item, index)=>legendEntrySvg(item, index, bounds.x, bounds.y + 21 * index, 16)).join('');
+}
+function horizontalLegendEntries(items, bounds) {
+    if (!items.length) return '';
+    const columns = Math.max(1, Math.min(items.length, Math.floor(bounds.width / 96)));
+    const itemWidth = bounds.width / columns;
+    return items.map((item, index)=>{
+        const column = index % columns;
+        const row = Math.floor(index / columns);
+        return legendEntrySvg(item, index, bounds.x + column * itemWidth, bounds.y + 17 * row + 9, Math.max(8, Math.floor(itemWidth / 7)));
+    }).join('');
+}
+function legendEntrySvg(item, index, x, baselineY, maximumCharacters) {
+    return [
+        `<rect data-chart-legend-entry="${index}" x="${roundChartNumber(x)}" y="${roundChartNumber(baselineY - 9)}" width="10" height="10" rx="2" fill="${item.color}"/>`,
+        `<text x="${roundChartNumber(x + 16)}" y="${roundChartNumber(baselineY)}" fill="#536078" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10">${escapeChartXml(truncateChartText(item.label, maximumCharacters))}</text>`
+    ].join('');
+}
+function spreadsheetChartSeriesLayout(chart) {
+    const grouping = normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type);
+    const stacked = workSpreadsheetChartGroupingIsStacked(grouping);
+    const categoryCount = Math.max(1, chart.categories.length, ...chart.series.map((series)=>series.values.length));
+    const result = chart.series.map(()=>[]);
+    for(let categoryIndex = 0; categoryIndex < categoryCount; categoryIndex += 1){
+        const rawValues = chart.series.map((series)=>finiteChartNumber(series.values[categoryIndex] ?? 0));
+        const positiveTotal = rawValues.reduce((sum, value)=>sum + Math.max(0, value), 0);
+        const negativeTotal = rawValues.reduce((sum, value)=>sum + Math.abs(Math.min(0, value)), 0);
+        let positive = 0;
+        let negative = 0;
+        rawValues.forEach((rawValue, seriesIndex)=>{
+            const value = 'percentStacked' === grouping ? rawValue >= 0 ? positiveTotal ? rawValue / positiveTotal : 0 : negativeTotal ? rawValue / negativeTotal : 0 : rawValue;
+            const start = stacked ? value >= 0 ? positive : negative : 0;
+            const end = start + value;
+            if (stacked) if (value >= 0) positive = end;
+            else negative = end;
+            if (categoryIndex < (chart.series[seriesIndex]?.values.length ?? 0)) result[seriesIndex].push({
+                categoryIndex,
+                rawValue,
+                start,
+                end
+            });
+        });
+    }
+    const scaleValues = result.flatMap((series)=>series.flatMap((point)=>[
+                point.start,
+                point.end
+            ]));
+    return {
+        grouping,
+        stacked,
+        categoryCount,
+        series: result,
+        scaleValues
+    };
+}
+function spreadsheetChartBarGeometry(groupSize, seriesCount, chart, maximumBarSize) {
+    const grouping = normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type);
+    const gapWidth = normalizeWorkSpreadsheetChartGapWidth(chart.gapWidth);
+    const overlap = normalizeWorkSpreadsheetChartOverlap(chart.overlap, grouping);
+    const count = Math.max(1, seriesCount);
+    const clusterSize = Math.max(1, 100 * groupSize / (100 + gapWidth));
+    const stepRatio = 1 - overlap / 100;
+    const idealBarSize = clusterSize / Math.max(1, 1 + (count - 1) * stepRatio);
+    const barSize = Math.max(1, Math.min(maximumBarSize, idealBarSize));
+    const step = barSize * stepRatio;
+    const totalSize = barSize + step * (count - 1);
+    const start = (groupSize - totalSize) / 2;
+    return {
+        barSize,
+        renderedSize: Math.max(0.75, barSize - Math.min(1.5, 0.08 * barSize)),
+        offset: (seriesIndex)=>start + seriesIndex * step
+    };
+}
+function spreadsheetDataLabelSvg(chart, seriesIndex, pointIndex, geometry) {
+    const series = chart.series[seriesIndex];
+    if (!series?.dataLabels) return '';
+    const labels = normalizeWorkSpreadsheetDataLabels(series.dataLabels, chart.type);
+    const text = spreadsheetDataLabelText(chart, seriesIndex, pointIndex);
+    if (!text) return '';
+    const position = normalizeWorkSpreadsheetDataLabelPosition(labels.position);
+    const placed = placeDataLabel(geometry, position);
+    const visualText = truncateChartText(text.replaceAll(/\r?\n/g, ' '), 32);
+    return `<text data-data-label-series="${seriesIndex}:${pointIndex}" data-data-label-position="${position}" data-data-label-text="${escapeChartXml(text)}" x="${roundChartNumber(placed.x)}" y="${roundChartNumber(placed.y)}" fill="#27344d" stroke="#ffffff" stroke-width="3" stroke-linejoin="round" paint-order="stroke" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="9" font-weight="500" text-anchor="${placed.anchor}">${escapeChartXml(visualText)}</text>`;
+}
+function spreadsheetDataLabelText(chart, seriesIndex, pointIndex) {
+    const series = chart.series[seriesIndex];
+    if (!series?.dataLabels) return '';
+    const labels = normalizeWorkSpreadsheetDataLabels(series.dataLabels, chart.type);
+    const parts = [];
+    if (labels.showSeriesName) parts.push(series.name || `系列 ${seriesIndex + 1}`);
+    if (labels.showCategoryName) {
+        const category = 'scatter' === chart.type || 'bubble' === chart.type ? compactChartNumber(series.xValues?.[pointIndex] ?? pointIndex + 1) : chart.categories[pointIndex] ?? String(pointIndex + 1);
+        parts.push(category);
+    }
+    if (labels.showValue) parts.push(compactChartNumber(series.values[pointIndex]));
+    if (labels.showPercentage) {
+        const values = series.values.map((value)=>Math.max(0, finiteChartNumber(value)));
+        const total = values.reduce((sum, value)=>sum + value, 0);
+        if (total > 0) parts.push(`${compactChartNumber(Math.round(values[pointIndex] / total * 1000) / 10)}%`);
+    }
+    if (labels.showBubbleSize) parts.push(compactChartNumber(series.bubbleSizes?.[pointIndex] ?? 0));
+    return parts.join(labels.separator ?? ', ');
+}
+function placeDataLabel(geometry, position) {
+    if ('verticalBar' === geometry.kind) return placeVerticalBarLabel(geometry, position);
+    if ('horizontalBar' === geometry.kind) return placeHorizontalBarLabel(geometry, position);
+    if ('circular' === geometry.kind) return placeCircularLabel(geometry, position);
+    if ('left' === position) return {
+        x: geometry.x - 6,
+        y: geometry.y + 3,
+        anchor: 'end'
+    };
+    if ('right' === position) return {
+        x: geometry.x + 6,
+        y: geometry.y + 3,
+        anchor: 'start'
+    };
+    if ('below' === position) return {
+        x: geometry.x,
+        y: geometry.y + 13,
+        anchor: 'middle'
+    };
+    if ('center' === position || 'insideBase' === position || 'insideEnd' === position) return {
+        x: geometry.x,
+        y: geometry.y + 3,
+        anchor: 'middle'
+    };
+    return {
+        x: geometry.x,
+        y: geometry.y - 7,
+        anchor: 'middle'
+    };
+}
+function placeVerticalBarLabel(geometry, position) {
+    const positive = geometry.value >= 0;
+    if ('left' === position) return {
+        x: geometry.x - 5,
+        y: geometry.valueY + 3,
+        anchor: 'end'
+    };
+    if ('right' === position) return {
+        x: geometry.x + 5,
+        y: geometry.valueY + 3,
+        anchor: 'start'
+    };
+    if ('center' === position) return {
+        x: geometry.x,
+        y: (geometry.valueY + geometry.baselineY) / 2 + 3,
+        anchor: 'middle'
+    };
+    if ('insideBase' === position) return {
+        x: geometry.x,
+        y: geometry.baselineY + (positive ? -5 : 12),
+        anchor: 'middle'
+    };
+    if ('insideEnd' === position) return {
+        x: geometry.x,
+        y: geometry.valueY + (positive ? 11 : -5),
+        anchor: 'middle'
+    };
+    if ('below' === position) return {
+        x: geometry.x,
+        y: geometry.valueY + 13,
+        anchor: 'middle'
+    };
+    return {
+        x: geometry.x,
+        y: geometry.valueY + (positive ? -6 : 13),
+        anchor: 'middle'
+    };
+}
+function placeHorizontalBarLabel(geometry, position) {
+    const positive = geometry.value >= 0;
+    if ('above' === position) return {
+        x: geometry.valueX,
+        y: geometry.y - 5,
+        anchor: 'middle'
+    };
+    if ('below' === position) return {
+        x: geometry.valueX,
+        y: geometry.y + 12,
+        anchor: 'middle'
+    };
+    if ('center' === position) return {
+        x: (geometry.valueX + geometry.baselineX) / 2,
+        y: geometry.y + 3,
+        anchor: 'middle'
+    };
+    if ('insideBase' === position) return {
+        x: geometry.baselineX + (positive ? 5 : -5),
+        y: geometry.y + 3,
+        anchor: positive ? 'start' : 'end'
+    };
+    if ('insideEnd' === position) return {
+        x: geometry.valueX + (positive ? -5 : 5),
+        y: geometry.y + 3,
+        anchor: positive ? 'end' : 'start'
+    };
+    if ('left' === position) return {
+        x: geometry.valueX - 6,
+        y: geometry.y + 3,
+        anchor: 'end'
+    };
+    if ('right' === position) return {
+        x: geometry.valueX + 6,
+        y: geometry.y + 3,
+        anchor: 'start'
+    };
+    return {
+        x: geometry.valueX + (positive ? 6 : -6),
+        y: geometry.y + 3,
+        anchor: positive ? 'start' : 'end'
+    };
+}
+function placeCircularLabel(geometry, position) {
+    const thickness = geometry.outerRadius - geometry.innerRadius;
+    const radius = 'outsideEnd' === position ? geometry.outerRadius + 14 : 'insideBase' === position ? geometry.innerRadius + 0.28 * thickness : 'insideEnd' === position ? geometry.innerRadius + 0.76 * thickness : geometry.innerRadius + 0.58 * thickness;
+    const x = geometry.centerX + Math.cos(geometry.angle) * radius;
+    const y = geometry.centerY + Math.sin(geometry.angle) * radius;
+    if ('left' === position) return {
+        x: x - 8,
+        y: y + 3,
+        anchor: 'end'
+    };
+    if ('right' === position) return {
+        x: x + 8,
+        y: y + 3,
+        anchor: 'start'
+    };
+    if ('above' === position) return {
+        x,
+        y: y - 7,
+        anchor: 'middle'
+    };
+    if ('below' === position) return {
+        x,
+        y: y + 13,
+        anchor: 'middle'
+    };
+    const anchor = 'outsideEnd' === position ? Math.cos(geometry.angle) >= 0 ? 'start' : 'end' : 'middle';
+    return {
+        x,
+        y: y + 3,
+        anchor
+    };
+}
+function spreadsheetErrorBarAmounts(series, source, chartType) {
+    const errorBars = normalizeWorkSpreadsheetErrorBars(source, chartType);
+    const values = errorBarSourceValues(series, errorBars);
+    const sharedAmount = sharedErrorAmount(values, errorBars);
+    return values.map((value, index)=>{
+        const amount = 'percentage' === errorBars.valueType ? Math.abs(value) * ((errorBars.value ?? 5) / 100) : 'custom' === errorBars.valueType ? 0 : sharedAmount;
+        const minus = 'custom' === errorBars.valueType ? finiteNonNegative(errorBars.minusValues?.[index]) : amount;
+        const plus = 'custom' === errorBars.valueType ? finiteNonNegative(errorBars.plusValues?.[index]) : amount;
+        return {
+            minus: 'plus' === errorBars.barType ? 0 : minus,
+            plus: 'minus' === errorBars.barType ? 0 : plus
+        };
+    });
+}
+function spreadsheetSeriesErrorBarBounds(series, chartType, direction) {
+    const values = 'x' === direction ? numericXValues(series) : series.values;
+    const matching = (series.errorBars ?? []).filter((source)=>normalizeWorkSpreadsheetErrorBars(source, chartType).direction === direction);
+    if (!matching.length) return values.filter(Number.isFinite);
+    return matching.flatMap((source)=>{
+        const amounts = spreadsheetErrorBarAmounts(series, source, chartType);
+        return values.flatMap((value, index)=>{
+            if (!Number.isFinite(value)) return [];
+            const amount = amounts[index] ?? {
+                minus: 0,
+                plus: 0
+            };
+            return [
+                value - amount.minus,
+                value,
+                value + amount.plus
+            ];
+        });
+    });
+}
+function errorBarSourceValues(series, errorBars) {
+    return 'x' === errorBars.direction ? numericXValues(series) : series.values;
+}
+function numericXValues(series) {
+    return series.values.map((_, index)=>series.xValues?.[index] ?? index + 1);
+}
+function sharedErrorAmount(values, errorBars) {
+    if ('fixedValue' === errorBars.valueType) return errorBars.value ?? 1;
+    if ('standardDeviation' === errorBars.valueType) return populationStandardDeviation(values) * (errorBars.value ?? 1);
+    if ('standardError' === errorBars.valueType) {
+        const usableCount = values.filter(Number.isFinite).length;
+        return usableCount ? populationStandardDeviation(values) / Math.sqrt(usableCount) : 0;
+    }
+    return 0;
+}
+function populationStandardDeviation(values) {
+    const usable = values.filter(Number.isFinite);
+    if (!usable.length) return 0;
+    const mean = usable.reduce((sum, value)=>sum + value, 0) / usable.length;
+    return Math.sqrt(usable.reduce((sum, value)=>sum + (value - mean) ** 2, 0) / usable.length);
+}
+function finiteNonNegative(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, position) {
+    const series = chart.series[seriesIndex];
+    if (!series?.errorBars?.length) return '';
+    const color = WORK_SPREADSHEET_CHART_COLORS[seriesIndex % WORK_SPREADSHEET_CHART_COLORS.length];
+    return series.errorBars.map((source, errorBarIndex)=>{
+        const errorBars = normalizeWorkSpreadsheetErrorBars(source, chart.type);
+        const values = errorBarSourceValues(series, errorBars);
+        const amounts = spreadsheetErrorBarAmounts(series, errorBars, chart.type);
+        const points = values.map((value, pointIndex)=>{
+            if (!Number.isFinite(value)) return '';
+            const amount = amounts[pointIndex] ?? {
+                minus: 0,
+                plus: 0
+            };
+            const start = position(errorBars.direction, pointIndex, value - amount.minus);
+            const end = position(errorBars.direction, pointIndex, value + amount.plus);
+            const horizontal = Math.abs(end[0] - start[0]) >= Math.abs(end[1] - start[1]);
+            const caps = false === errorBars.showEndCaps ? '' : `${amount.minus > 0 ? errorBarCap(start, horizontal) : ''}${amount.plus > 0 ? errorBarCap(end, horizontal) : ''}`;
+            return `<g data-error-bar-point="${seriesIndex}:${errorBarIndex}:${pointIndex}" data-error-minus="${roundChartNumber(amount.minus)}" data-error-plus="${roundChartNumber(amount.plus)}"><path d="M ${roundChartNumber(start[0])} ${roundChartNumber(start[1])} L ${roundChartNumber(end[0])} ${roundChartNumber(end[1])}" fill="none" stroke="${color}" stroke-width="1.4"/>${caps}</g>`;
+        }).join('');
+        return `<g data-error-bars-series="${seriesIndex}:${errorBarIndex}" data-error-bars-direction="${errorBars.direction}" data-error-bars-type="${errorBars.barType}" data-error-bars-value-type="${errorBars.valueType}" data-error-bars-end-caps="${false !== errorBars.showEndCaps}" color="${color}">${points}</g>`;
+    }).join('');
+}
+function errorBarCap(point, horizontal) {
+    return horizontal ? `<path d="M ${roundChartNumber(point[0])} ${roundChartNumber(point[1] - 4)} L ${roundChartNumber(point[0])} ${roundChartNumber(point[1] + 4)}" fill="none" stroke="currentColor" stroke-width="1.4"/>` : `<path d="M ${roundChartNumber(point[0] - 4)} ${roundChartNumber(point[1])} L ${roundChartNumber(point[0] + 4)} ${roundChartNumber(point[1])}" fill="none" stroke="currentColor" stroke-width="1.4"/>`;
+}
+const DEFAULT_TICK_COUNT = 5;
+const MAX_RENDERED_TICKS = 64;
+function workSpreadsheetChartAxisIsValueAxis(chartType, position) {
+    if (!workSpreadsheetChartSupportsAxes(chartType) || 'top' === position) return false;
+    if (workSpreadsheetChartUsesNumericXAxis(chartType)) return 'bottom' === position || 'left' === position;
+    if ('bar' === chartType) return 'bottom' === position;
+    if ('combination' === chartType) return 'left' === position || 'right' === position;
+    return 'left' === position;
+}
+function workSpreadsheetChartAxisIsCategoryAxis(chartType, position) {
+    if (!workSpreadsheetChartSupportsAxes(chartType) || workSpreadsheetChartUsesNumericXAxis(chartType)) return false;
+    if ('bar' === chartType) return 'left' === position;
+    if ('combination' === chartType) return 'bottom' === position || 'top' === position;
+    return 'bottom' === position;
+}
+function workSpreadsheetChartAxisShowsMajorGridlinesByDefault(chartType, position) {
+    if (!workSpreadsheetChartAxisIsValueAxis(chartType, position)) return false;
+    if (workSpreadsheetChartUsesNumericXAxis(chartType)) return 'left' === position;
+    if ('bar' === chartType) return 'bottom' === position;
+    return 'left' === position;
+}
+function workSpreadsheetChartAxisDefaultLabelPosition(chartType, position) {
+    return 'combination' === chartType && 'top' === position ? 'none' : 'nextTo';
+}
+function workSpreadsheetChartAxisPositionLabel(position) {
+    if ('left' === position) return '纵轴';
+    if ('top' === position) return '次横轴';
+    if ('right' === position) return '次纵轴';
+    return '横轴';
+}
+function workSpreadsheetChartAxisLabelPositionLabel(position) {
+    if ('high' === position) return '高位';
+    if ('low' === position) return '低位';
+    if ('none' === position) return '不显示';
+    return '轴旁';
+}
+function workSpreadsheetChartAxisTickMarkLabel(tickMark) {
+    if ('inside' === tickMark) return '向内';
+    if ('outside' === tickMark) return '向外';
+    if ('cross' === tickMark) return '交叉';
+    return '无';
+}
+function normalizeWorkSpreadsheetChartAxes(source, chartType, hasSecondaryAxes = false) {
+    if (!source || !workSpreadsheetChartSupportsAxes(chartType)) return;
+    const bottom = normalizeWorkSpreadsheetChartAxis(source.bottom, chartType, 'bottom');
+    const left = normalizeWorkSpreadsheetChartAxis(source.left, chartType, 'left');
+    const top = 'combination' === chartType && hasSecondaryAxes ? normalizeWorkSpreadsheetChartAxis(source.top, chartType, 'top') : void 0;
+    const right = 'combination' === chartType && hasSecondaryAxes ? normalizeWorkSpreadsheetChartAxis(source.right, chartType, 'right') : void 0;
+    return bottom || left || top || right ? {
+        ...bottom ? {
+            bottom
+        } : {},
+        ...left ? {
+            left
+        } : {},
+        ...top ? {
+            top
+        } : {},
+        ...right ? {
+            right
+        } : {}
+    } : void 0;
+}
+function normalizeWorkSpreadsheetChartAxis(source, chartType, position) {
+    if (!source) return;
+    const title = source.title?.trim();
+    const titleReference = source.titleReference?.trim().replace(/^=/, '');
+    const valueAxis = workSpreadsheetChartAxisIsValueAxis(chartType, position);
+    const categoryAxis = workSpreadsheetChartAxisIsCategoryAxis(chartType, position);
+    const minimum = valueAxis && Number.isFinite(source.minimum) ? Number(source.minimum) : void 0;
+    const maximum = valueAxis && Number.isFinite(source.maximum) ? Number(source.maximum) : void 0;
+    const validRange = void 0 === minimum || void 0 === maximum || minimum < maximum;
+    const majorUnit = valueAxis && Number.isFinite(source.majorUnit) && Number(source.majorUnit) > 0 ? Number(source.majorUnit) : void 0;
+    const showMajorGridlines = valueAxis && 'boolean' == typeof source.showMajorGridlines ? source.showMajorGridlines : void 0;
+    const numberFormat = valueAxis ? source.numberFormat?.trim().slice(0, 255) : void 0;
+    const numberFormatSourceLinked = valueAxis && 'boolean' == typeof source.numberFormatSourceLinked ? source.numberFormatSourceLinked : void 0;
+    const labelPosition = normalizedAxisLabelPosition(source.labelPosition);
+    const defaultLabelPosition = workSpreadsheetChartAxisDefaultLabelPosition(chartType, position);
+    const majorTickMark = normalizedAxisTickMark(source.majorTickMark);
+    const labelInterval = categoryAxis ? normalizedLabelInterval(source.labelInterval) : void 0;
+    const normalized = {
+        ...title ? {
+            title
+        } : {},
+        ...titleReference ? {
+            titleReference
+        } : {},
+        ...true === source.reverseOrder ? {
+            reverseOrder: true
+        } : {},
+        ...labelPosition && labelPosition !== defaultLabelPosition ? {
+            labelPosition
+        } : {},
+        ...majorTickMark && 'none' !== majorTickMark ? {
+            majorTickMark
+        } : {},
+        ...void 0 !== labelInterval ? {
+            labelInterval
+        } : {},
+        ...validRange && void 0 !== minimum ? {
+            minimum
+        } : {},
+        ...validRange && void 0 !== maximum ? {
+            maximum
+        } : {},
+        ...void 0 !== majorUnit ? {
+            majorUnit
+        } : {},
+        ...void 0 !== showMajorGridlines ? {
+            showMajorGridlines
+        } : {},
+        ...numberFormat ? {
+            numberFormat
+        } : {},
+        ...void 0 !== numberFormatSourceLinked ? {
+            numberFormatSourceLinked
+        } : {}
+    };
+    return Object.keys(normalized).length ? normalized : void 0;
+}
+function normalizedAxisLabelPosition(value) {
+    return 'nextTo' === value || 'high' === value || 'low' === value || 'none' === value ? value : void 0;
+}
+function normalizedAxisTickMark(value) {
+    return 'none' === value || 'inside' === value || 'outside' === value || 'cross' === value ? value : void 0;
+}
+function normalizedLabelInterval(value) {
+    const interval = Number(value);
+    return Number.isInteger(interval) && interval >= 1 && interval <= 31999 ? interval : void 0;
+}
+function spreadsheetChartAxisDisplayAttributes(axis, chartType, position) {
+    const labelPosition = axis?.labelPosition ?? workSpreadsheetChartAxisDefaultLabelPosition(chartType, position);
+    const majorTickMark = axis?.majorTickMark ?? 'none';
+    return [
+        `data-axis-display="${position}"`,
+        `data-axis-reverse-order="${axis?.reverseOrder === true}"`,
+        `data-axis-label-position="${labelPosition}"`,
+        `data-axis-major-tick-mark="${majorTickMark}"`,
+        workSpreadsheetChartAxisIsCategoryAxis(chartType, position) ? `data-axis-label-interval="${axis?.labelInterval ?? 'auto'}"` : ''
+    ].filter(Boolean).join(' ');
+}
+function spreadsheetChartAxisValueRatio(value, scale, axis) {
+    const ratio = Math.min(1, Math.max(0, (finiteChartNumber(value) - scale.minimum) / scale.span));
+    return axis?.reverseOrder === true ? 1 - ratio : ratio;
+}
+function spreadsheetChartCategoryVisualIndex(index, count, axis) {
+    return axis?.reverseOrder === true ? count - 1 - index : index;
+}
+function spreadsheetChartCategoryLabelVisible(index, count, axis) {
+    const explicitInterval = normalizedLabelInterval(axis?.labelInterval);
+    const interval = explicitInterval ?? Math.max(1, Math.ceil(count / 7));
+    return index % interval === 0 || void 0 === explicitInterval && index === count - 1;
+}
+function spreadsheetChartAxisLabelLayout(axis, chartType, position, plot, tickX, tickY) {
+    const labelPosition = axis?.labelPosition ?? workSpreadsheetChartAxisDefaultLabelPosition(chartType, position);
+    if ('none' === labelPosition) return null;
+    if ('bottom' === position) return {
+        x: tickX,
+        y: 'high' === labelPosition ? plot.y - 7 : plot.y + plot.height + 18,
+        textAnchor: 'middle'
+    };
+    if ('top' === position) return {
+        x: tickX,
+        y: 'low' === labelPosition ? plot.y + plot.height + 18 : plot.y - 7,
+        textAnchor: 'middle'
+    };
+    if ('left' === position) {
+        const high = 'high' === labelPosition;
+        return {
+            x: high ? plot.x + plot.width + 8 : plot.x - 8,
+            y: tickY + 4,
+            textAnchor: high ? 'start' : 'end'
+        };
+    }
+    const low = 'low' === labelPosition;
+    return {
+        x: low ? plot.x - 8 : plot.x + plot.width + 8,
+        y: tickY + 4,
+        textAnchor: low ? 'end' : 'start'
+    };
+}
+function spreadsheetChartMajorTickSvg(axis, position, index, x, y) {
+    const mark = axis?.majorTickMark ?? 'none';
+    if ('none' === mark) return '';
+    const inward = 'bottom' === position ? [
+        0,
+        -1
+    ] : 'top' === position ? [
+        0,
+        1
+    ] : 'left' === position ? [
+        1,
+        0
+    ] : [
+        -1,
+        0
+    ];
+    const insideLength = 'outside' === mark ? 0 : 'cross' === mark ? 3 : 5;
+    const outsideLength = 'inside' === mark ? 0 : 'cross' === mark ? 3 : 5;
+    const x1 = x - inward[0] * outsideLength;
+    const y1 = y - inward[1] * outsideLength;
+    const x2 = x + inward[0] * insideLength;
+    const y2 = y + inward[1] * insideLength;
+    return `<line data-axis-major-tick="${position}:${index}" x1="${roundChartNumber(x1)}" y1="${roundChartNumber(y1)}" x2="${roundChartNumber(x2)}" y2="${roundChartNumber(y2)}" stroke="#7d8798" stroke-width="1"/>`;
+}
+function spreadsheetChartAxisScale(values, axis, options = {}) {
+    const finiteValues = values.filter(Number.isFinite).map(finiteChartNumber);
+    const sourceValues = finiteValues.length ? finiteValues : [
+        0,
+        1
+    ];
+    let automaticMinimum = Math.min(...sourceValues);
+    let automaticMaximum = Math.max(...sourceValues);
+    if (options.includeZero) {
+        automaticMinimum = Math.min(0, automaticMinimum);
+        automaticMaximum = Math.max(0, automaticMaximum);
+    }
+    const sourceSpan = automaticMaximum - automaticMinimum;
+    const paddingRatio = Math.max(0, options.paddingRatio ?? 0);
+    const padding = sourceSpan > 0 ? sourceSpan * paddingRatio : Math.max(1, Math.abs(automaticMinimum) * Math.max(paddingRatio, 0.05));
+    automaticMinimum -= padding;
+    automaticMaximum += padding;
+    let minimum = Number.isFinite(axis?.minimum) ? Number(axis?.minimum) : automaticMinimum;
+    let maximum = Number.isFinite(axis?.maximum) ? Number(axis?.maximum) : automaticMaximum;
+    const fallbackSpan = Math.max(Number.isFinite(axis?.majorUnit) && Number(axis?.majorUnit) > 0 ? Number(axis?.majorUnit) : 0, 0.1 * Math.abs(minimum), 0.1 * Math.abs(maximum), 1);
+    if (!(minimum < maximum)) if (axis?.minimum !== void 0 && void 0 === axis.maximum) maximum = minimum + fallbackSpan;
+    else if (axis?.maximum !== void 0 && void 0 === axis.minimum) minimum = maximum - fallbackSpan;
+    else {
+        minimum = automaticMinimum;
+        maximum = automaticMaximum;
+    }
+    if (!(minimum < maximum)) maximum = minimum + fallbackSpan;
+    const span = Math.max(Number.EPSILON, maximum - minimum);
+    const majorUnit = Number.isFinite(axis?.majorUnit) && Number(axis?.majorUnit) > 0 ? Number(axis?.majorUnit) : void 0;
+    return {
+        minimum,
+        maximum,
+        span,
+        ...void 0 !== majorUnit ? {
+            majorUnit
+        } : {},
+        ticks: axisTicks(minimum, maximum, majorUnit)
+    };
+}
+function spreadsheetChartAxisGridlinesVisible(axis, chartType, position) {
+    return axis?.showMajorGridlines ?? workSpreadsheetChartAxisShowsMajorGridlinesByDefault(chartType, position);
+}
+function spreadsheetChartAxisScaleAttributes(axis, scale, chartType, position) {
+    return [
+        `data-axis-scale="${position}"`,
+        `data-axis-minimum="${roundChartNumber(scale.minimum)}"`,
+        `data-axis-maximum="${roundChartNumber(scale.maximum)}"`,
+        void 0 === scale.majorUnit ? '' : `data-axis-major-unit="${roundChartNumber(scale.majorUnit)}"`,
+        `data-axis-gridlines="${spreadsheetChartAxisGridlinesVisible(axis, chartType, position)}"`,
+        axis?.numberFormat ? `data-axis-number-format="${escapeChartXml(axis.numberFormat)}"` : '',
+        axis?.numberFormatSourceLinked === void 0 ? '' : `data-axis-number-format-source-linked="${axis.numberFormatSourceLinked}"`,
+        spreadsheetChartAxisDisplayAttributes(axis, chartType, position)
+    ].filter(Boolean).join(' ');
+}
+function formatSpreadsheetChartAxisNumber(value, formatCode) {
+    const code = formatCode?.trim();
+    if (!code || /^general$/i.test(code)) return compactChartNumber(value);
+    const section = code.split(';')[value < 0 ? 1 : 0] || code.split(';')[0] || code;
+    const percent = section.includes('%');
+    const scientific = /e[+-]/i.test(section);
+    const decimalPattern = /[0#]+\.([0#]+)/.exec(section);
+    const decimals = Math.min(12, decimalPattern?.[1].length ?? 0);
+    const scaled = percent ? 100 * value : value;
+    let formatted;
+    if (scientific) {
+        const [mantissa, exponentText] = scaled.toExponential(decimals).split('e');
+        const exponent = Number(exponentText);
+        const exponentWidth = /e[+-](0+)/i.exec(section)?.[1].length ?? 1;
+        formatted = `${mantissa}E${exponent >= 0 ? '+' : '-'}${String(Math.abs(exponent)).padStart(exponentWidth, '0')}`;
+    } else formatted = new Intl.NumberFormat('en-US', {
+        useGrouping: section.includes(','),
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals
+    }).format(scaled);
+    const currency = /[$¥€£]/.exec(section)?.[0] ?? '';
+    return `${currency}${formatted}${percent ? '%' : ''}`;
+}
+function axisTicks(minimum, maximum, majorUnit) {
+    if (void 0 === majorUnit) return Array.from({
+        length: DEFAULT_TICK_COUNT
+    }, (_, index)=>normalizedTick(minimum + index / (DEFAULT_TICK_COUNT - 1) * (maximum - minimum)));
+    const epsilon = Math.max(Number.EPSILON, 1e-9 * Math.abs(majorUnit));
+    const first = Math.ceil((minimum - epsilon) / majorUnit) * majorUnit;
+    const count = Math.floor((maximum - first + epsilon) / majorUnit) + 1;
+    if (count <= 0) return [
+        normalizedTick(minimum),
+        normalizedTick(maximum)
+    ];
+    if (count > MAX_RENDERED_TICKS) {
+        const step = Math.ceil(count / MAX_RENDERED_TICKS);
+        return Array.from({
+            length: Math.ceil(count / step)
+        }, (_, index)=>normalizedTick(first + index * step * majorUnit)).filter((value)=>value <= maximum + epsilon);
+    }
+    return Array.from({
+        length: count
+    }, (_, index)=>normalizedTick(first + index * majorUnit));
+}
+function normalizedTick(value) {
+    return Math.abs(value) < 1e-12 ? 0 : Math.round(1e12 * value) / 1e12;
+}
+function spreadsheetLineChartSvg(chart, plot, valuePosition, layout) {
+    const pointX = (index)=>1 === layout.categoryCount ? plot.x + plot.width / 2 : plot.x + (spreadsheetChartCategoryVisualIndex(index, layout.categoryCount, chart.axes?.bottom) + 0.5) / layout.categoryCount * plot.width;
+    const smooth = 'line' === chart.type && normalizeWorkSpreadsheetChartSmoothLines(chart.smoothLines);
+    return layout.series.map((points, seriesIndex)=>{
+        const positioned = points.map((point)=>({
+                ...point,
+                x: pointX(point.categoryIndex),
+                startY: valuePosition(point.start),
+                endY: valuePosition(point.end)
+            }));
+        if (!positioned.length) return '';
+        const path = chartLinePath(positioned.map((point)=>[
+                point.x,
+                point.endY
+            ]), smooth);
+        const series = chart.series[seriesIndex];
+        const fill = spreadsheetChartSeriesFillStyle(series, seriesIndex, 0.2);
+        const line = spreadsheetChartSeriesLineStyle(series, seriesIndex, 2.5);
+        const area = 'area' === chart.type ? `<path data-area-series="${seriesIndex}" data-area-baseline="${layout.stacked ? 'stacked' : 'zero'}" d="${stackedAreaPath(positioned)}" ${fill.attributes}/>` : '';
+        const markers = positioned.map((point)=>spreadsheetChartSeriesMarkerSvg(series, seriesIndex, point.x, point.endY, {
+                visible: true,
+                defaultSize: 5,
+                attributes: `data-chart-point="${seriesIndex}:${point.categoryIndex}" data-stack-start="${roundChartNumber(point.start)}" data-stack-end="${roundChartNumber(point.end)}"`
+            })).join('');
+        const dataLabels = positioned.map((point)=>spreadsheetDataLabelSvg(chart, seriesIndex, point.categoryIndex, {
+                kind: 'point',
+                x: point.x,
+                y: point.endY
+            })).join('');
+        const errorBars = layout.stacked ? '' : spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, (_direction, pointIndex, value)=>[
+                pointX(pointIndex),
+                valuePosition(value)
+            ]);
+        return `${area}${errorBars}<path data-line-series="${seriesIndex}" data-smooth="${smooth}" d="${path}" fill="none" ${line.attributes} stroke-linejoin="round" stroke-linecap="round"/>${markers}${dataLabels}`;
+    }).join('');
+}
+function stackedAreaPath(points) {
+    const upper = points.map((point, index)=>`${index ? 'L' : 'M'} ${roundChartNumber(point.x)} ${roundChartNumber(point.endY)}`);
+    const lower = [
+        ...points
+    ].reverse().map((point)=>`L ${roundChartNumber(point.x)} ${roundChartNumber(point.startY)}`);
+    return [
+        ...upper,
+        ...lower,
+        'Z'
+    ].join(' ');
+}
+function chartLinePath(points, smooth) {
+    if (!points.length) return '';
+    if (!smooth || points.length < 3) return points.map(([x, y], index)=>`${index ? 'L' : 'M'} ${roundChartNumber(x)} ${roundChartNumber(y)}`).join(' ');
+    const commands = [
+        `M ${roundChartNumber(points[0][0])} ${roundChartNumber(points[0][1])}`
+    ];
+    for(let index = 0; index < points.length - 1; index += 1){
+        const previous = points[index - 1] ?? points[index];
+        const current = points[index];
+        const next = points[index + 1];
+        const following = points[index + 2] ?? next;
+        commands.push(`C ${roundChartNumber(current[0] + (next[0] - previous[0]) / 6)} ${roundChartNumber(current[1] + (next[1] - previous[1]) / 6)} ${roundChartNumber(next[0] - (following[0] - current[0]) / 6)} ${roundChartNumber(next[1] - (following[1] - current[1]) / 6)} ${roundChartNumber(next[0])} ${roundChartNumber(next[1])}`);
+    }
+    return commands.join(' ');
+}
+function fitSpreadsheetTrendline(xValues, yValues, source) {
+    const trendline = normalizeWorkSpreadsheetTrendline(source);
+    const observed = yValues.flatMap((y, index)=>{
+        const x = xValues[index];
+        return Number.isFinite(x) && Number.isFinite(y) ? [
+            {
+                x,
+                y
+            }
+        ] : [];
+    });
+    if (observed.length < 2) return null;
+    if ('movingAverage' === trendline.type) return movingAverageFit(observed, trendline.period ?? 2);
+    const model = regressionModel(observed, trendline);
+    if (!model) return null;
+    const minimum = Math.min(...observed.map((point)=>point.x)) - (trendline.backward ?? 0);
+    const maximum = Math.max(...observed.map((point)=>point.x)) + (trendline.forward ?? 0);
+    const points = sampledPoints(minimum, maximum, model.predict);
+    if (points.length < 2) return null;
+    return {
+        points,
+        equation: model.equation,
+        rSquared: coefficientOfDetermination(observed, model.predict)
+    };
+}
+function regressionModel(observed, trendline) {
+    if ('linear' === trendline.type) return polynomialModel(observed, 1, trendline.intercept);
+    if ('polynomial' === trendline.type) return polynomialModel(observed, Math.min(trendline.order ?? 2, observed.length - 1), trendline.intercept);
+    if ('exponential' === trendline.type) {
+        const usable = observed.filter((point)=>point.y > 0);
+        const coefficients = linearCoefficients(usable.map((point)=>({
+                x: point.x,
+                y: Math.log(point.y)
+            })));
+        if (!coefficients) return null;
+        const [intercept, slope] = coefficients;
+        const factor = Math.exp(intercept);
+        return {
+            predict: (x)=>factor * Math.exp(slope * x),
+            equation: `y = ${formatCoefficient(factor)}e^(${formatCoefficient(slope)}x)`
+        };
+    }
+    if ('logarithmic' === trendline.type) {
+        const usable = observed.filter((point)=>point.x > 0);
+        const coefficients = linearCoefficients(usable.map((point)=>({
+                x: Math.log(point.x),
+                y: point.y
+            })));
+        if (!coefficients) return null;
+        const [intercept, slope] = coefficients;
+        return {
+            predict: (x)=>x > 0 ? intercept + slope * Math.log(x) : NaN,
+            equation: `y = ${formatCoefficient(slope)}ln(x) ${signedConstant(intercept)}`
+        };
+    }
+    if ('power' === trendline.type) {
+        const usable = observed.filter((point)=>point.x > 0 && point.y > 0);
+        const coefficients = linearCoefficients(usable.map((point)=>({
+                x: Math.log(point.x),
+                y: Math.log(point.y)
+            })));
+        if (!coefficients) return null;
+        const [intercept, exponent] = coefficients;
+        const factor = Math.exp(intercept);
+        return {
+            predict: (x)=>x > 0 ? factor * x ** exponent : NaN,
+            equation: `y = ${formatCoefficient(factor)}x^${formatCoefficient(exponent)}`
+        };
+    }
+    return null;
+}
+function polynomialModel(observed, order, fixedIntercept) {
+    const startPower = void 0 === fixedIntercept ? 0 : 1;
+    const coefficientCount = order - startPower + 1;
+    if (coefficientCount < 1 || observed.length < coefficientCount) return null;
+    const matrix = Array.from({
+        length: coefficientCount
+    }, (_, row)=>Array.from({
+            length: coefficientCount
+        }, (_, column)=>observed.reduce((sum, point)=>sum + point.x ** (row + column + 2 * startPower), 0)));
+    const vector = Array.from({
+        length: coefficientCount
+    }, (_, row)=>observed.reduce((sum, point)=>sum + point.x ** (row + startPower) * (point.y - (fixedIntercept ?? 0)), 0));
+    const solved = solveLinearSystem(matrix, vector);
+    if (!solved) return null;
+    const coefficients = void 0 === fixedIntercept ? solved : [
+        fixedIntercept,
+        ...solved
+    ];
+    const predict = (x)=>coefficients.reduce((sum, coefficient, power)=>sum + coefficient * x ** power, 0);
+    return {
+        predict,
+        equation: polynomialEquation(coefficients)
+    };
+}
+function linearCoefficients(observed) {
+    if (observed.length < 2) return null;
+    const count = observed.length;
+    const sumX = observed.reduce((sum, point)=>sum + point.x, 0);
+    const sumY = observed.reduce((sum, point)=>sum + point.y, 0);
+    const sumXX = observed.reduce((sum, point)=>sum + point.x * point.x, 0);
+    const sumXY = observed.reduce((sum, point)=>sum + point.x * point.y, 0);
+    const denominator = count * sumXX - sumX * sumX;
+    if (Math.abs(denominator) < 1e-12) return null;
+    const slope = (count * sumXY - sumX * sumY) / denominator;
+    return [
+        (sumY - slope * sumX) / count,
+        slope
+    ];
+}
+function solveLinearSystem(matrix, vector) {
+    const size = vector.length;
+    const augmented = matrix.map((row, index)=>[
+            ...row,
+            vector[index]
+        ]);
+    for(let column = 0; column < size; column += 1){
+        let pivot = column;
+        for(let row = column + 1; row < size; row += 1)if (Math.abs(augmented[row][column]) > Math.abs(augmented[pivot][column])) pivot = row;
+        if (Math.abs(augmented[pivot][column]) < 1e-12) return null;
+        [augmented[column], augmented[pivot]] = [
+            augmented[pivot],
+            augmented[column]
+        ];
+        const divisor = augmented[column][column];
+        for(let index = column; index <= size; index += 1)augmented[column][index] /= divisor;
+        for(let row = 0; row < size; row += 1){
+            if (row === column) continue;
+            const factor = augmented[row][column];
+            for(let index = column; index <= size; index += 1)augmented[row][index] -= factor * augmented[column][index];
+        }
+    }
+    return augmented.map((row)=>row[size]);
+}
+function sampledPoints(minimum, maximum, predict) {
+    const span = maximum - minimum;
+    if (!Number.isFinite(span) || span <= 0) return [];
+    return Array.from({
+        length: 65
+    }, (_, index)=>{
+        const x = minimum + index / 64 * span;
+        return {
+            x,
+            y: predict(x)
+        };
+    }).filter((point)=>Number.isFinite(point.y));
+}
+function movingAverageFit(observed, period) {
+    if (observed.length < period) return null;
+    const points = observed.slice(period - 1).map((point, index)=>({
+            x: point.x,
+            y: observed.slice(index, index + period).reduce((sum, item)=>sum + item.y, 0) / period
+        }));
+    return {
+        points,
+        equation: `Moving average (${period})`
+    };
+}
+function coefficientOfDetermination(observed, predict) {
+    const usable = observed.map((point)=>({
+            actual: point.y,
+            predicted: predict(point.x)
+        })).filter((point)=>Number.isFinite(point.predicted));
+    if (usable.length < 2) return;
+    const mean = usable.reduce((sum, point)=>sum + point.actual, 0) / usable.length;
+    const total = usable.reduce((sum, point)=>sum + (point.actual - mean) ** 2, 0);
+    const residual = usable.reduce((sum, point)=>sum + (point.actual - point.predicted) ** 2, 0);
+    if (total < 1e-12) return residual < 1e-12 ? 1 : 0;
+    return Math.max(0, Math.min(1, 1 - residual / total));
+}
+function polynomialEquation(coefficients) {
+    const terms = coefficients.map((coefficient, power)=>{
+        if (Math.abs(coefficient) < 1e-10) return '';
+        const absolute = formatCoefficient(Math.abs(coefficient));
+        const variable = 0 === power ? '' : 1 === power ? 'x' : `x^${power}`;
+        return `${coefficient < 0 ? '-' : '+'}${absolute}${variable}`;
+    }).filter(Boolean);
+    if (!terms.length) return 'y = 0';
+    return `y = ${terms.join(' ').replace(/^\+/, '').replaceAll('+', '+ ').replaceAll('-', '- ').trim()}`;
+}
+function formatCoefficient(value) {
+    return String(roundChartNumber(value));
+}
+function signedConstant(value) {
+    return `${value < 0 ? '-' : '+'} ${formatCoefficient(Math.abs(value))}`;
+}
+function spreadsheetSeriesTrendlineFits(series, xValues) {
+    return (series.trendlines ?? []).flatMap((source, sourceIndex)=>{
+        const fit = fitSpreadsheetTrendline(xValues, series.values, source);
+        return fit ? [
+            {
+                sourceIndex,
+                fit
+            }
+        ] : [];
+    });
+}
+function spreadsheetSeriesTrendlinesSvg(series, seriesIndex, xValues, position) {
+    const color = WORK_SPREADSHEET_CHART_COLORS[seriesIndex % WORK_SPREADSHEET_CHART_COLORS.length];
+    return spreadsheetSeriesTrendlineFits(series, xValues).map(({ sourceIndex, fit })=>{
+        const trendline = normalizeWorkSpreadsheetTrendline(series.trendlines?.[sourceIndex] ?? {
+            type: 'linear'
+        });
+        const points = fit.points.map((point)=>position(point.x, point.y));
+        if (points.length < 2) return '';
+        const path = points.map(([x, y], index)=>`${index ? 'L' : 'M'} ${roundChartNumber(x)} ${roundChartNumber(y)}`).join(' ');
+        const equation = trendline.displayEquation && fit.equation ? fit.equation : void 0;
+        const rSquared = trendline.displayRSquared && void 0 !== fit.rSquared ? roundChartNumber(fit.rSquared) : void 0;
+        const label = [
+            equation,
+            void 0 === rSquared ? '' : `R² = ${rSquared}`
+        ].filter(Boolean).join(' · ');
+        const labelPoint = points.at(-1);
+        return [
+            `<g data-trendline-series="${seriesIndex}:${sourceIndex}" data-trendline-type="${trendline.type}"${trendline.name ? ` data-trendline-name="${escapeChartXml(trendline.name)}"` : ''}${equation ? ` data-trendline-equation="${escapeChartXml(equation)}"` : ''}${void 0 === rSquared ? '' : ` data-trendline-r-squared="${rSquared}"`}>`,
+            `<path d="${path}" fill="none" stroke="${color}" stroke-width="2" stroke-dasharray="${sourceIndex % 2 ? '3 3' : '7 4'}" stroke-linecap="round"/>`,
+            label ? `<text x="${roundChartNumber(labelPoint[0] - 4)}" y="${roundChartNumber(labelPoint[1] - 7 - 12 * sourceIndex)}" fill="${color}" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="9" text-anchor="end">${escapeChartXml(label)}</text>` : '',
+            '</g>'
+        ].join('');
+    }).join('');
+}
+function spreadsheetCombinationChartSvg(chart, plot) {
+    const values = chart.series.flatMap((series)=>combinationSeriesValues(series));
+    if (!values.length) return emptyCombinationChartSvg(plot);
+    const hasSecondaryAxis = chart.series.some((series)=>'secondary' === normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup));
+    const primaryValues = chart.series.filter((series)=>'primary' === normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup)).flatMap((series)=>combinationSeriesValues(series));
+    const secondaryValues = chart.series.filter((series)=>'secondary' === normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup)).flatMap((series)=>combinationSeriesValues(series));
+    const primaryAxis = combinationAxis(primaryValues.length ? primaryValues : values, plot, chart.axes?.left);
+    const secondaryAxis = combinationAxis(secondaryValues.length ? secondaryValues : values, plot, chart.axes?.right);
+    const categoryCount = Math.max(1, chart.categories.length, ...chart.series.map((series)=>series.values.length));
+    const pointX = (index, axis)=>1 === categoryCount ? plot.x + plot.width / 2 : plot.x + (spreadsheetChartCategoryVisualIndex(index, categoryCount, axis) + 0.5) / categoryCount * plot.width;
+    const axisForSeries = (seriesIndex)=>'secondary' === normalizeWorkSpreadsheetChartAxisGroup(chart.series[seriesIndex]?.axisGroup) ? secondaryAxis : primaryAxis;
+    const pointXForSeries = (seriesIndex, index)=>pointX(index, 'secondary' === normalizeWorkSpreadsheetChartAxisGroup(chart.series[seriesIndex]?.axisGroup) ? chart.axes?.top : chart.axes?.bottom);
+    const areas = chart.series.map((series, seriesIndex)=>'area' === normalizeWorkSpreadsheetCombinationSeriesType(series.chartType) ? combinationAreaSeriesSvg(chart, seriesIndex, (index)=>pointXForSeries(seriesIndex, index), axisForSeries(seriesIndex)) : '').join('');
+    const columns = combinationColumnSeriesSvg(chart, plot, categoryCount, axisForSeries, pointXForSeries);
+    const lines = chart.series.map((series, seriesIndex)=>'line' === normalizeWorkSpreadsheetCombinationSeriesType(series.chartType) ? combinationLineSeriesSvg(chart, seriesIndex, (index)=>pointXForSeries(seriesIndex, index), axisForSeries(seriesIndex)) : '').join('');
+    const trendlines = chart.series.map((series, seriesIndex)=>spreadsheetSeriesTrendlinesSvg(series, seriesIndex, combinationTrendlineXValues(series), (x, y)=>[
+                pointXForSeries(seriesIndex, x - 1),
+                axisForSeries(seriesIndex).position(y)
+            ])).join('');
+    return `<g data-combination-chart="true">${combinationAxesSvg(chart, plot, primaryAxis, secondaryAxis, hasSecondaryAxis)}${areas}${columns}${lines}${trendlines}${combinationCategoryLabelsSvg(chart, plot, categoryCount)}</g>`;
+}
+function combinationTrendlineXValues(series) {
+    return series.values.map((_, index)=>index + 1);
+}
+function combinationTrendlineValues(series) {
+    return spreadsheetSeriesTrendlineFits(series, combinationTrendlineXValues(series)).flatMap((item)=>item.fit.points.map((point)=>point.y));
+}
+function combinationSeriesValues(series) {
+    return [
+        ...series.values.map(finiteChartNumber),
+        ...spreadsheetSeriesErrorBarBounds(series, 'combination', 'y'),
+        ...combinationTrendlineValues(series)
+    ];
+}
+function combinationAxis(values, plot, axis) {
+    const scale = spreadsheetChartAxisScale(values, axis, {
+        includeZero: true
+    });
+    return {
+        ...scale,
+        position: (value)=>plot.y + (1 - spreadsheetChartAxisValueRatio(value, scale, axis)) * plot.height
+    };
+}
+function combinationAxesSvg(chart, plot, primary, secondary, hasSecondary) {
+    const primaryAxis = chart.axes?.left;
+    const secondaryAxis = chart.axes?.right;
+    const primaryGridlines = spreadsheetChartAxisGridlinesVisible(primaryAxis, chart.type, 'left');
+    const secondaryGridlines = spreadsheetChartAxisGridlinesVisible(secondaryAxis, chart.type, 'right');
+    const grid = primary.ticks.map((value, index)=>{
+        const y = primary.position(value);
+        const label = spreadsheetChartAxisLabelLayout(primaryAxis, chart.type, 'left', plot, plot.x, y);
+        return `${primaryGridlines ? `<line x1="${plot.x}" y1="${roundChartNumber(y)}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(y)}" stroke="#e8ebf0" stroke-width="1"/>` : ''}${spreadsheetChartMajorTickSvg(primaryAxis, 'left', index, plot.x, y)}${label ? `<text data-axis-tick="left" x="${roundChartNumber(label.x)}" y="${roundChartNumber(label.y)}" fill="#717b8f" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${label.textAnchor}">${escapeChartXml(formatSpreadsheetChartAxisNumber(value, primaryAxis?.numberFormat))}</text>` : ''}`;
+    }).join('');
+    const secondaryLabels = hasSecondary ? `<g data-secondary-axis="true" ${spreadsheetChartAxisScaleAttributes(secondaryAxis, secondary, chart.type, 'right')}>${secondary.ticks.map((value, index)=>{
+        const y = secondary.position(value);
+        const label = spreadsheetChartAxisLabelLayout(secondaryAxis, chart.type, 'right', plot, plot.x + plot.width, y);
+        return `${secondaryGridlines ? `<line x1="${plot.x}" y1="${roundChartNumber(y)}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(y)}" stroke="#eef0f4" stroke-width="1" stroke-dasharray="2 2"/>` : ''}${spreadsheetChartMajorTickSvg(secondaryAxis, 'right', index, plot.x + plot.width, y)}${label ? `<text data-axis-tick="right" x="${roundChartNumber(label.x)}" y="${roundChartNumber(label.y)}" fill="#717b8f" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${label.textAnchor}">${escapeChartXml(formatSpreadsheetChartAxisNumber(value, secondaryAxis?.numberFormat))}</text>` : ''}`;
+    }).join('')}<line x1="${roundChartNumber(plot.x + plot.width)}" y1="${plot.y}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#aeb6c4" stroke-width="1.2"/></g>` : '';
+    return `<g ${spreadsheetChartAxisScaleAttributes(primaryAxis, primary, chart.type, 'left')}>${grid}<line x1="${plot.x}" y1="${plot.y}" x2="${plot.x}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#aeb6c4" stroke-width="1.2"/></g><g ${spreadsheetChartAxisDisplayAttributes(chart.axes?.bottom, chart.type, 'bottom')}><line x1="${plot.x}" y1="${roundChartNumber(plot.y + plot.height)}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#aeb6c4" stroke-width="1.2"/></g>${secondaryLabels}`;
+}
+function combinationAreaSeriesSvg(chart, seriesIndex, pointX, axis) {
+    const series = chart.series[seriesIndex];
+    const points = series.values.map((value, index)=>[
+            pointX(index),
+            axis.position(value)
+        ]);
+    if (!points.length) return '';
+    const fill = spreadsheetChartSeriesFillStyle(series, seriesIndex, 0.2);
+    const lineStyle = spreadsheetChartSeriesLineStyle(series, seriesIndex, 2);
+    const line = points.map(([x, y], index)=>`${index ? 'L' : 'M'} ${roundChartNumber(x)} ${roundChartNumber(y)}`).join(' ');
+    const baseline = axis.position(0);
+    const path = `${line} L ${roundChartNumber(points.at(-1)?.[0] ?? pointX(0))} ${roundChartNumber(baseline)} L ${roundChartNumber(points[0][0])} ${roundChartNumber(baseline)} Z`;
+    const dataLabels = points.map(([x, y], pointIndex)=>spreadsheetDataLabelSvg(chart, seriesIndex, pointIndex, {
+            kind: 'point',
+            x,
+            y
+        })).join('');
+    const errorBars = spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, (_direction, pointIndex, value)=>[
+            pointX(pointIndex),
+            axis.position(value)
+        ]);
+    return `<g data-combination-series="${seriesIndex}" data-series-chart-type="area" data-axis-group="${normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup)}"><path data-combination-area="${seriesIndex}" d="${path}" ${fill.attributes} ${lineStyle.attributes} stroke-linejoin="round"/>${errorBars}${dataLabels}</g>`;
+}
+function combinationColumnSeriesSvg(chart, plot, categoryCount, axisForSeries, pointXForSeries) {
+    const columnSeries = chart.series.flatMap((series, seriesIndex)=>'column' === normalizeWorkSpreadsheetCombinationSeriesType(series.chartType) ? [
+            {
+                series,
+                seriesIndex
+            }
+        ] : []);
+    if (!columnSeries.length) return '';
+    const groupWidth = plot.width / categoryCount;
+    const barWidth = Math.max(2, Math.min(36, 0.72 * groupWidth / columnSeries.length));
+    return columnSeries.map(({ series, seriesIndex }, columnIndex)=>{
+        const axis = axisForSeries(seriesIndex);
+        const baseline = axis.position(0);
+        const fill = spreadsheetChartSeriesFillStyle(series, seriesIndex);
+        const line = spreadsheetChartSeriesLineStyle(series, seriesIndex, 0);
+        const seriesX = (pointIndex)=>pointXForSeries(seriesIndex, pointIndex) - barWidth * columnSeries.length / 2 + columnIndex * barWidth;
+        const renderedWidth = Math.max(1, barWidth - 1.5);
+        const bars = series.values.map((value, index)=>{
+            const y = axis.position(value);
+            const x = seriesX(index);
+            return `<rect data-combination-column="${seriesIndex}:${index}" x="${roundChartNumber(x)}" y="${roundChartNumber(Math.min(y, baseline))}" width="${roundChartNumber(renderedWidth)}" height="${roundChartNumber(Math.max(1, Math.abs(y - baseline)))}" rx="1.5" ${fill.attributes} ${line.attributes}/>${spreadsheetDataLabelSvg(chart, seriesIndex, index, {
+                kind: 'verticalBar',
+                x: x + renderedWidth / 2,
+                valueY: y,
+                baselineY: baseline,
+                value
+            })}`;
+        }).join('');
+        const errorBars = spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, (_direction, pointIndex, value)=>[
+                seriesX(pointIndex) + renderedWidth / 2,
+                axis.position(value)
+            ]);
+        return `<g data-combination-series="${seriesIndex}" data-series-chart-type="column" data-axis-group="${normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup)}">${bars}${errorBars}</g>`;
+    }).join('');
+}
+function combinationLineSeriesSvg(chart, seriesIndex, pointX, axis) {
+    const series = chart.series[seriesIndex];
+    const points = series.values.map((value, index)=>[
+            pointX(index),
+            axis.position(value)
+        ]);
+    if (!points.length) return '';
+    const line = spreadsheetChartSeriesLineStyle(series, seriesIndex, 2.5);
+    const path = points.map(([x, y], index)=>`${index ? 'L' : 'M'} ${roundChartNumber(x)} ${roundChartNumber(y)}`).join(' ');
+    const markers = points.map(([x, y], pointIndex)=>spreadsheetChartSeriesMarkerSvg(series, seriesIndex, x, y, {
+            visible: true,
+            defaultSize: 5,
+            attributes: `data-combination-marker="${seriesIndex}:${pointIndex}"`
+        })).join('');
+    const dataLabels = points.map(([x, y], pointIndex)=>spreadsheetDataLabelSvg(chart, seriesIndex, pointIndex, {
+            kind: 'point',
+            x,
+            y
+        })).join('');
+    const errorBars = spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, (_direction, pointIndex, value)=>[
+            pointX(pointIndex),
+            axis.position(value)
+        ]);
+    return `<g data-combination-series="${seriesIndex}" data-series-chart-type="line" data-axis-group="${normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup)}">${errorBars}<path data-combination-line="${seriesIndex}" d="${path}" fill="none" ${line.attributes} stroke-linejoin="round" stroke-linecap="round"/>${markers}${dataLabels}</g>`;
+}
+function combinationCategoryLabelsSvg(chart, plot, categoryCount) {
+    const labels = (position, axis)=>{
+        const axisY = 'bottom' === position ? plot.y + plot.height : plot.y;
+        return Array.from({
+            length: categoryCount
+        }, (_, index)=>{
+            const visible = spreadsheetChartCategoryLabelVisible(index, categoryCount, axis);
+            const label = chart.categories[index] ?? String(index + 1);
+            const visualIndex = spreadsheetChartCategoryVisualIndex(index, categoryCount, axis);
+            const x = plot.x + (visualIndex + 0.5) / categoryCount * plot.width;
+            const labelLayout = spreadsheetChartAxisLabelLayout(axis, chart.type, position, plot, x, axisY);
+            return `${spreadsheetChartMajorTickSvg(axis, position, index, x, axisY)}${visible && labelLayout ? `<text data-axis-category-label="${position}:${index}" x="${roundChartNumber(labelLayout.x)}" y="${roundChartNumber(labelLayout.y)}" fill="#536078" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${labelLayout.textAnchor}">${escapeChartXml(truncateChartText(label, 13))}</text>` : ''}`;
+        }).join('');
+    };
+    const bottom = `<g ${spreadsheetChartAxisDisplayAttributes(chart.axes?.bottom, chart.type, 'bottom')}>${labels('bottom', chart.axes?.bottom)}</g>`;
+    const topAxis = chart.axes?.top;
+    const showTopAxis = (topAxis?.labelPosition ?? 'none') !== 'none' || (topAxis?.majorTickMark ?? 'none') !== 'none';
+    const top = showTopAxis ? `<g ${spreadsheetChartAxisDisplayAttributes(topAxis, chart.type, 'top')}><line x1="${plot.x}" y1="${plot.y}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${plot.y}" stroke="#aeb6c4" stroke-width="1.2"/>${labels('top', topAxis)}</g>` : '';
+    return `${bottom}${top}`;
+}
+function emptyCombinationChartSvg(plot) {
+    return `<text x="${roundChartNumber(plot.x + plot.width / 2)}" y="${roundChartNumber(plot.y + plot.height / 2)}" fill="#8791a3" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="13" text-anchor="middle">没有可绘制的数据</text>`;
+}
+function spreadsheetXyChartAxesSvg(chart, plot, xBounds, yBounds) {
+    const xAxis = chart.axes?.bottom;
+    const yAxis = chart.axes?.left;
+    const xGridlines = spreadsheetChartAxisGridlinesVisible(xAxis, chart.type, 'bottom');
+    const yGridlines = spreadsheetChartAxisGridlinesVisible(yAxis, chart.type, 'left');
+    const xTicks = xBounds.ticks.map((value, index)=>{
+        const x = plot.x + spreadsheetChartAxisValueRatio(value, xBounds, xAxis) * plot.width;
+        const label = spreadsheetChartAxisLabelLayout(xAxis, chart.type, 'bottom', plot, x, plot.y + plot.height);
+        return `${xGridlines ? `<line x1="${roundChartNumber(x)}" y1="${plot.y}" x2="${roundChartNumber(x)}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#eef0f4" stroke-width="1"/>` : ''}${spreadsheetChartMajorTickSvg(xAxis, 'bottom', index, x, plot.y + plot.height)}${label ? `<text data-axis-tick="bottom" x="${roundChartNumber(label.x)}" y="${roundChartNumber(label.y)}" fill="#717b8f" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${label.textAnchor}">${escapeChartXml(formatSpreadsheetChartAxisNumber(value, xAxis?.numberFormat))}</text>` : ''}`;
+    }).join('');
+    const yTicks = yBounds.ticks.map((value, index)=>{
+        const y = plot.y + (1 - spreadsheetChartAxisValueRatio(value, yBounds, yAxis)) * plot.height;
+        const label = spreadsheetChartAxisLabelLayout(yAxis, chart.type, 'left', plot, plot.x, y);
+        return `${yGridlines ? `<line x1="${plot.x}" y1="${roundChartNumber(y)}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(y)}" stroke="#e8ebf0" stroke-width="1"/>` : ''}${spreadsheetChartMajorTickSvg(yAxis, 'left', index, plot.x, y)}${label ? `<text data-axis-tick="left" x="${roundChartNumber(label.x)}" y="${roundChartNumber(label.y)}" fill="#717b8f" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${label.textAnchor}">${escapeChartXml(formatSpreadsheetChartAxisNumber(value, yAxis?.numberFormat))}</text>` : ''}`;
+    }).join('');
+    return `<g ${spreadsheetChartAxisScaleAttributes(xAxis, xBounds, chart.type, 'bottom')}>${xTicks}<line x1="${plot.x}" y1="${roundChartNumber(plot.y + plot.height)}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#aeb6c4" stroke-width="1.2"/></g><g ${spreadsheetChartAxisScaleAttributes(yAxis, yBounds, chart.type, 'left')}>${yTicks}<line x1="${plot.x}" y1="${plot.y}" x2="${plot.x}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#aeb6c4" stroke-width="1.2"/></g>`;
+}
+const WIDTH = 640;
+const HEIGHT = 360;
+function spreadsheetChartSvgDataUrl(chart) {
+    return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(spreadsheetChartSvg(chart))}`;
+}
+function spreadsheetChartSvg(chart) {
+    const title = chart.title?.trim();
+    const titleHeight = title ? 42 : 16;
+    const circular = 'pie' === chart.type || 'doughnut' === chart.type;
+    const polar = 'radar' === chart.type;
+    const xy = 'scatter' === chart.type || 'bubble' === chart.type;
+    const hasSecondaryAxis = 'combination' === chart.type && chart.series.some((series)=>'secondary' === normalizeWorkSpreadsheetChartAxisGroup(series.axisGroup));
+    const axes = normalizeWorkSpreadsheetChartAxes(chart.axes, chart.type, hasSecondaryAxis);
+    const grouping = normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type);
+    const renderedChart = {
+        ...chart,
+        axes,
+        ...workSpreadsheetChartSupportsGrouping(chart.type) ? {
+            grouping
+        } : {},
+        ...workSpreadsheetChartSupportsBarSpacing(chart.type) ? {
+            gapWidth: normalizeWorkSpreadsheetChartGapWidth(chart.gapWidth),
+            overlap: normalizeWorkSpreadsheetChartOverlap(chart.overlap, grouping)
+        } : {},
+        ...workSpreadsheetChartSupportsSmoothLines(chart.type) ? {
+            smoothLines: normalizeWorkSpreadsheetChartSmoothLines(chart.smoothLines)
+        } : {}
+    };
+    const topAxisTitleHeight = axes?.top?.title ? 18 : 0;
+    const secondaryAxisWidth = hasSecondaryAxis ? axes?.right?.title ? 58 : 44 : 0;
+    const plotLeft = 'bar' === chart.type ? 88 : circular || polar ? 24 : xy ? 64 : 56;
+    const basePlot = {
+        x: plotLeft,
+        y: titleHeight + 12 + topAxisTitleHeight,
+        width: WIDTH - plotLeft - 18 - secondaryAxisWidth,
+        height: HEIGHT - titleHeight - 54 - topAxisTitleHeight
+    };
+    const legend = spreadsheetChartLegendLayout(renderedChart, basePlot, {
+        width: WIDTH,
+        height: HEIGHT,
+        titleHeight
+    });
+    const plot = legend.plot;
+    const plotAttributes = spreadsheetChartPlotAttributes(renderedChart, plot);
+    const plotSvg = 'pie' === chart.type ? pieChartSvg(renderedChart, plot) : 'doughnut' === chart.type ? doughnutChartSvg(renderedChart, plot) : 'radar' === chart.type ? radarChartSvg(renderedChart, plot) : xy ? xyChartSvg(renderedChart, plot) : 'combination' === chart.type ? spreadsheetCombinationChartSvg(renderedChart, plot) : cartesianChartSvg(renderedChart, plot);
+    return [
+        `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${WIDTH} ${HEIGHT}" preserveAspectRatio="none" data-chart-type="${escapeChartXml(String(chart.type))}">`,
+        '<rect width="640" height="360" rx="8" fill="#ffffff"/>',
+        '<rect x="0.75" y="0.75" width="638.5" height="358.5" rx="7.25" fill="none" stroke="#d9dee8" stroke-width="1.5"/>',
+        title ? `<text x="${WIDTH / 2}" y="27" fill="#172033" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="17" font-weight="600" text-anchor="middle">${escapeChartXml(title)}</text>` : '',
+        `<g ${plotAttributes}>${plotSvg}</g>`,
+        axes ? chartAxisTitlesSvg(axes, plot) : '',
+        legend.svg,
+        '</svg>'
+    ].join('');
+}
+function spreadsheetChartPlotAttributes(chart, plot) {
+    const attributes = [
+        'data-plot-area="true"',
+        `data-plot-x="${roundChartNumber(plot.x)}"`,
+        `data-plot-y="${roundChartNumber(plot.y)}"`,
+        `data-plot-width="${roundChartNumber(plot.width)}"`,
+        `data-plot-height="${roundChartNumber(plot.height)}"`
+    ];
+    if (workSpreadsheetChartSupportsGrouping(chart.type)) attributes.push(`data-chart-grouping="${normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type)}"`);
+    if (workSpreadsheetChartSupportsBarSpacing(chart.type)) {
+        const grouping = normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type);
+        attributes.push(`data-chart-gap-width="${normalizeWorkSpreadsheetChartGapWidth(chart.gapWidth)}"`);
+        attributes.push(`data-chart-overlap="${normalizeWorkSpreadsheetChartOverlap(chart.overlap, grouping)}"`);
+    }
+    if (workSpreadsheetChartSupportsSmoothLines(chart.type)) attributes.push(`data-chart-smooth-lines="${normalizeWorkSpreadsheetChartSmoothLines(chart.smoothLines)}"`);
+    return attributes.join(' ');
+}
+function chartAxisTitlesSvg(axes, plot) {
+    const bottom = chartAxisTitleText(axes.bottom?.title);
+    const left = chartAxisTitleText(axes.left?.title);
+    const top = chartAxisTitleText(axes.top?.title);
+    const right = chartAxisTitleText(axes.right?.title);
+    const font = 'font-family="-apple-system,BlinkMacSystemFont,\'Segoe UI\',sans-serif" font-size="11" font-weight="600"';
+    const bottomY = Math.min(HEIGHT - 7, plot.y + plot.height + 35);
+    const leftX = Math.max(13, plot.x - 43);
+    const rightX = plot.x + plot.width + 45;
+    return [
+        bottom ? `<text data-axis-title="bottom" x="${roundChartNumber(plot.x + plot.width / 2)}" y="${roundChartNumber(bottomY)}" fill="#3f4a60" ${font} text-anchor="middle">${escapeChartXml(bottom)}</text>` : '',
+        left ? `<text data-axis-title="left" x="${roundChartNumber(leftX)}" y="${roundChartNumber(plot.y + plot.height / 2)}" fill="#3f4a60" ${font} text-anchor="middle" transform="rotate(-90 ${roundChartNumber(leftX)} ${roundChartNumber(plot.y + plot.height / 2)})">${escapeChartXml(left)}</text>` : '',
+        top ? `<text data-axis-title="top" x="${roundChartNumber(plot.x + plot.width / 2)}" y="${roundChartNumber(plot.y - 7)}" fill="#3f4a60" ${font} text-anchor="middle">${escapeChartXml(top)}</text>` : '',
+        right ? `<text data-axis-title="right" x="${roundChartNumber(rightX)}" y="${roundChartNumber(plot.y + plot.height / 2)}" fill="#3f4a60" ${font} text-anchor="middle" transform="rotate(90 ${roundChartNumber(rightX)} ${roundChartNumber(plot.y + plot.height / 2)})">${escapeChartXml(right)}</text>` : ''
+    ].join('');
+}
+function chartAxisTitleText(title) {
+    return title?.trim() ? truncateChartText(title.trim(), 54) : '';
+}
+function doughnutChartSvg(chart, plot) {
+    const hasValues = chart.series.some((series)=>series.values.some((value)=>Math.max(0, finiteChartNumber(value)) > 0));
+    if (!hasValues) return emptyChartSvg(plot, '没有可绘制的数据');
+    const centerX = plot.x + plot.width / 2;
+    const centerY = plot.y + plot.height / 2;
+    const radius = Math.max(24, 0.4 * Math.min(plot.width, plot.height));
+    const holeSize = normalizeWorkSpreadsheetDoughnutHoleSize(chart.doughnutHoleSize);
+    const holeRadius = holeSize / 100 * radius;
+    const ringWidth = (radius - holeRadius) / Math.max(1, chart.series.length);
+    const ringGap = Math.min(1, 0.18 * ringWidth);
+    const rings = chart.series.map((_, seriesIndex)=>{
+        const outerRadius = radius - seriesIndex * ringWidth;
+        const innerRadius = holeRadius + (chart.series.length - seriesIndex - 1) * ringWidth + (seriesIndex < chart.series.length - 1 ? ringGap : 0);
+        return `<g data-doughnut-series="${seriesIndex}">${doughnutRingSvg(chart, seriesIndex, centerX, centerY, innerRadius, outerRadius)}</g>`;
+    }).join('');
+    return `<g data-hole-size="${holeSize}">${rings}</g>`;
+}
+function doughnutRingSvg(chart, seriesIndex, centerX, centerY, innerRadius, outerRadius) {
+    const values = chart.series[seriesIndex]?.values ?? [];
+    const usableValues = values.map((value)=>Math.max(0, finiteChartNumber(value)));
+    const total = usableValues.reduce((sum, value)=>sum + value, 0);
+    if (!total) return '';
+    const positiveIndices = usableValues.flatMap((value, index)=>value > 0 ? [
+            index
+        ] : []);
+    if (1 === positiveIndices.length) {
+        const index = positiveIndices[0];
+        const middleRadius = (innerRadius + outerRadius) / 2;
+        const fill = spreadsheetChartSeriesFillStyle(chart.series[seriesIndex], seriesIndex, 1, WORK_SPREADSHEET_CHART_COLORS[index % WORK_SPREADSHEET_CHART_COLORS.length]);
+        return `<circle cx="${roundChartNumber(centerX)}" cy="${roundChartNumber(centerY)}" r="${roundChartNumber(middleRadius)}" fill="none" stroke="${fill.color}" stroke-opacity="${fill.opacity}" stroke-width="${roundChartNumber(outerRadius - innerRadius)}" data-chart-slice="${seriesIndex}:${index}"/>${spreadsheetDataLabelSvg(chart, seriesIndex, index, {
+            kind: 'circular',
+            centerX,
+            centerY,
+            angle: 0,
+            innerRadius,
+            outerRadius
+        })}`;
+    }
+    let angle = -Math.PI / 2;
+    return usableValues.map((value, index)=>{
+        const nextAngle = angle + value / total * Math.PI * 2;
+        const middleAngle = angle + (nextAngle - angle) / 2;
+        if (!value) {
+            angle = nextAngle;
+            return '';
+        }
+        const largeArc = nextAngle - angle > Math.PI ? 1 : 0;
+        const outerStartX = centerX + Math.cos(angle) * outerRadius;
+        const outerStartY = centerY + Math.sin(angle) * outerRadius;
+        const outerEndX = centerX + Math.cos(nextAngle) * outerRadius;
+        const outerEndY = centerY + Math.sin(nextAngle) * outerRadius;
+        const innerEndX = centerX + Math.cos(nextAngle) * innerRadius;
+        const innerEndY = centerY + Math.sin(nextAngle) * innerRadius;
+        const innerStartX = centerX + Math.cos(angle) * innerRadius;
+        const innerStartY = centerY + Math.sin(angle) * innerRadius;
+        const path = [
+            `M ${roundChartNumber(outerStartX)} ${roundChartNumber(outerStartY)}`,
+            `A ${roundChartNumber(outerRadius)} ${roundChartNumber(outerRadius)} 0 ${largeArc} 1 ${roundChartNumber(outerEndX)} ${roundChartNumber(outerEndY)}`,
+            `L ${roundChartNumber(innerEndX)} ${roundChartNumber(innerEndY)}`,
+            `A ${roundChartNumber(innerRadius)} ${roundChartNumber(innerRadius)} 0 ${largeArc} 0 ${roundChartNumber(innerStartX)} ${roundChartNumber(innerStartY)}`,
+            'Z'
+        ].join(' ');
+        angle = nextAngle;
+        const fill = spreadsheetChartSeriesFillStyle(chart.series[seriesIndex], seriesIndex, 1, WORK_SPREADSHEET_CHART_COLORS[index % WORK_SPREADSHEET_CHART_COLORS.length]);
+        const line = spreadsheetChartSeriesLineStyle(chart.series[seriesIndex], seriesIndex, 1, '#FFFFFF');
+        return `<path data-chart-slice="${seriesIndex}:${index}" d="${path}" ${fill.attributes} ${line.attributes}/>${spreadsheetDataLabelSvg(chart, seriesIndex, index, {
+            kind: 'circular',
+            centerX,
+            centerY,
+            angle: middleAngle,
+            innerRadius,
+            outerRadius
+        })}`;
+    }).join('');
+}
+function radarChartSvg(chart, plot) {
+    const categoryCount = Math.max(0, chart.categories.length, ...chart.series.map((series)=>series.values.length));
+    if (categoryCount < 3) return emptyChartSvg(plot, '雷达图至少需要三个分类');
+    const values = chart.series.flatMap((series)=>series.values).map(finiteChartNumber);
+    if (!values.length) return emptyChartSvg(plot, '没有可绘制的数据');
+    const axis = chart.axes?.left;
+    const categoryAxis = chart.axes?.bottom;
+    const scale = spreadsheetChartAxisScale(values, axis, {
+        includeZero: true
+    });
+    const centerX = plot.x + plot.width / 2;
+    const centerY = plot.y + plot.height / 2;
+    const radius = Math.max(24, 0.36 * Math.min(plot.width, plot.height));
+    const point = (index, ratio)=>{
+        const visualIndex = spreadsheetChartCategoryVisualIndex(index, categoryCount, categoryAxis);
+        const angle = -Math.PI / 2 + visualIndex / categoryCount * Math.PI * 2;
+        return [
+            centerX + Math.cos(angle) * radius * ratio,
+            centerY + Math.sin(angle) * radius * ratio
+        ];
+    };
+    const polygon = (ratio)=>Array.from({
+            length: categoryCount
+        }, (_, index)=>point(index, ratio).map(roundChartNumber).join(',')).join(' ');
+    const showGridlines = spreadsheetChartAxisGridlinesVisible(axis, chart.type, 'left');
+    const grid = scale.ticks.filter((tick)=>tick > scale.minimum).map((tick, index)=>{
+        const ratio = spreadsheetChartAxisValueRatio(tick, scale, axis);
+        const labelVisible = (axis?.labelPosition ?? 'nextTo') !== 'none';
+        const tickY = centerY - radius * ratio;
+        return `${showGridlines ? `<polygon points="${polygon(ratio)}" fill="none" stroke="#dfe4ec" stroke-width="1"/>` : ''}${spreadsheetChartMajorTickSvg(axis, 'left', index, centerX, tickY)}${labelVisible ? `<text data-axis-tick="left" x="${roundChartNumber(centerX + 4)}" y="${roundChartNumber(tickY + 10)}" fill="#717b8f" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="9" text-anchor="start">${escapeChartXml(formatSpreadsheetChartAxisNumber(tick, axis?.numberFormat))}</text>` : ''}`;
+    }).join('');
+    const spokes = Array.from({
+        length: categoryCount
+    }, (_, index)=>{
+        const [x, y] = point(index, 1);
+        return `<line x1="${roundChartNumber(centerX)}" y1="${roundChartNumber(centerY)}" x2="${roundChartNumber(x)}" y2="${roundChartNumber(y)}" stroke="#e8ebf0" stroke-width="1"/>`;
+    }).join('');
+    const labels = Array.from({
+        length: categoryCount
+    }, (_, index)=>{
+        const [x, y] = point(index, 1.14);
+        const [tickX, tickY] = point(index, 1);
+        const horizontal = x - centerX;
+        const anchor = Math.abs(horizontal) < 8 ? 'middle' : horizontal > 0 ? 'start' : 'end';
+        const visible = (categoryAxis?.labelPosition ?? 'nextTo') !== 'none' && spreadsheetChartCategoryLabelVisible(index, categoryCount, categoryAxis);
+        return `${spreadsheetChartMajorTickSvg(categoryAxis, 'bottom', index, tickX, tickY)}${visible ? `<text data-axis-category-label="${index}" x="${roundChartNumber(x)}" y="${roundChartNumber(y + 4)}" fill="#536078" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${anchor}">${escapeChartXml(truncateChartText(chart.categories[index] ?? String(index + 1), 13))}</text>` : ''}`;
+    }).join('');
+    const style = normalizeWorkSpreadsheetRadarStyle(chart.radarStyle);
+    const series = chart.series.map((item, seriesIndex)=>{
+        const customStyle = normalizeWorkSpreadsheetChartSeriesStyle(item.style);
+        const fill = spreadsheetChartSeriesFillStyle(item, seriesIndex, customStyle?.fillColor ? 1 : 'filled' === style ? 0.24 : 0);
+        const line = spreadsheetChartSeriesLineStyle(item, seriesIndex, 2.2);
+        const points = Array.from({
+            length: categoryCount
+        }, (_, index)=>{
+            const value = finiteChartNumber(item.values[index] ?? 0);
+            return point(index, spreadsheetChartAxisValueRatio(value, scale, axis));
+        });
+        const pointList = points.map(([x, y])=>`${roundChartNumber(x)},${roundChartNumber(y)}`).join(' ');
+        const markers = points.map(([x, y])=>spreadsheetChartSeriesMarkerSvg(item, seriesIndex, x, y, {
+                visible: 'marker' === style,
+                defaultSize: 5
+            })).join('');
+        const dataLabels = points.map(([x, y], pointIndex)=>spreadsheetDataLabelSvg(chart, seriesIndex, pointIndex, {
+                kind: 'point',
+                x,
+                y
+            })).join('');
+        return `<g data-radar-series="${seriesIndex}"><polygon points="${pointList}" ${fill.attributes} ${line.attributes} stroke-linejoin="round"/>${markers}${dataLabels}</g>`;
+    }).join('');
+    return `<g data-radar-style="${style}"><g ${spreadsheetChartAxisScaleAttributes(axis, scale, chart.type, 'left')}>${grid}</g>${spokes}${series}<g ${spreadsheetChartAxisDisplayAttributes(categoryAxis, chart.type, 'bottom')}>${labels}</g></g>`;
+}
+function pieChartSvg(chart, plot) {
+    const values = chart.series[0]?.values ?? [];
+    const usableValues = values.map((value)=>Math.max(0, finiteChartNumber(value)));
+    const total = usableValues.reduce((sum, value)=>sum + value, 0);
+    if (!total) return emptyChartSvg(plot, '没有可绘制的数据');
+    const centerX = plot.x + plot.width / 2;
+    const centerY = plot.y + plot.height / 2;
+    const radius = Math.max(24, 0.38 * Math.min(plot.width, plot.height));
+    let angle = -Math.PI / 2;
+    return usableValues.map((value, index)=>{
+        const nextAngle = angle + value / total * Math.PI * 2;
+        const middleAngle = angle + (nextAngle - angle) / 2;
+        const largeArc = nextAngle - angle > Math.PI ? 1 : 0;
+        const startX = centerX + Math.cos(angle) * radius;
+        const startY = centerY + Math.sin(angle) * radius;
+        const endX = centerX + Math.cos(nextAngle) * radius;
+        const endY = centerY + Math.sin(nextAngle) * radius;
+        const series = chart.series[0];
+        const fill = spreadsheetChartSeriesFillStyle(series, 0, 1, WORK_SPREADSHEET_CHART_COLORS[index % WORK_SPREADSHEET_CHART_COLORS.length]);
+        const line = spreadsheetChartSeriesLineStyle(series, 0, 0, '#FFFFFF');
+        const path = 1 === usableValues.length ? `<circle data-chart-slice="0:${index}" cx="${roundChartNumber(centerX)}" cy="${roundChartNumber(centerY)}" r="${roundChartNumber(radius)}" ${fill.attributes} ${line.attributes}/>` : `<path data-chart-slice="0:${index}" d="M ${roundChartNumber(centerX)} ${roundChartNumber(centerY)} L ${roundChartNumber(startX)} ${roundChartNumber(startY)} A ${roundChartNumber(radius)} ${roundChartNumber(radius)} 0 ${largeArc} 1 ${roundChartNumber(endX)} ${roundChartNumber(endY)} Z" ${fill.attributes} ${line.attributes}/>`;
+        angle = nextAngle;
+        return `${path}${spreadsheetDataLabelSvg(chart, 0, index, {
+            kind: 'circular',
+            centerX,
+            centerY,
+            angle: middleAngle,
+            innerRadius: 0,
+            outerRadius: radius
+        })}`;
+    }).join('');
+}
+function xyChartSvg(chart, plot) {
+    const showNegativeBubbles = true === chart.showNegativeBubbles;
+    const seriesPoints = chart.series.map((series)=>spreadsheetXySeriesPoints(series, 'bubble' === chart.type, showNegativeBubbles));
+    const points = seriesPoints.flat();
+    if (!points.length) return emptyChartSvg(plot, 'bubble' === chart.type ? '气泡图需要 X、Y 和非零气泡大小数据' : '散点图需要 X 和 Y 数值');
+    const trendlinePoints = chart.series.flatMap((series)=>spreadsheetSeriesTrendlineFits(series, spreadsheetTrendlineXValues(series)).flatMap((item)=>item.fit.points));
+    const scaledPoints = [
+        ...points,
+        ...trendlinePoints
+    ];
+    const paddingRatio = 'bubble' === chart.type ? 0.18 : 0.06;
+    const xBounds = spreadsheetChartAxisScale([
+        ...scaledPoints.map((point)=>point.x),
+        ...chart.series.flatMap((series)=>spreadsheetSeriesErrorBarBounds(series, chart.type, 'x'))
+    ], chart.axes?.bottom, {
+        paddingRatio
+    });
+    const yBounds = spreadsheetChartAxisScale([
+        ...scaledPoints.map((point)=>point.y),
+        ...chart.series.flatMap((series)=>spreadsheetSeriesErrorBarBounds(series, chart.type, 'y'))
+    ], chart.axes?.left, {
+        paddingRatio
+    });
+    const pointX = (value)=>plot.x + spreadsheetChartAxisValueRatio(value, xBounds, chart.axes?.bottom) * plot.width;
+    const pointY = (value)=>plot.y + (1 - spreadsheetChartAxisValueRatio(value, yBounds, chart.axes?.left)) * plot.height;
+    const axes = spreadsheetXyChartAxesSvg(chart, plot, xBounds, yBounds);
+    const errorBars = chart.series.map((series, seriesIndex)=>spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, (direction, pointIndex, value)=>{
+            const x = series.xValues?.[pointIndex] ?? pointIndex + 1;
+            const y = series.values[pointIndex] ?? 0;
+            return 'x' === direction ? [
+                pointX(value),
+                pointY(y)
+            ] : [
+                pointX(x),
+                pointY(value)
+            ];
+        })).join('');
+    const trendlines = chart.series.map((series, seriesIndex)=>spreadsheetSeriesTrendlinesSvg(series, seriesIndex, spreadsheetTrendlineXValues(series), (x, y)=>[
+                pointX(x),
+                pointY(y)
+            ])).join('');
+    if ('bubble' === chart.type) return `${axes}${errorBars}${bubbleSeriesSvg(chart, seriesPoints, pointX, pointY)}${trendlines}`;
+    return `${axes}${errorBars}${scatterSeriesSvg(chart, seriesPoints, pointX, pointY)}${trendlines}`;
+}
+function spreadsheetTrendlineXValues(series) {
+    return series.values.map((_, index)=>series.xValues?.[index] ?? index + 1);
+}
+function spreadsheetXySeriesPoints(series, requireBubbleSize, showNegativeBubbles) {
+    return series.values.flatMap((rawY, sourceIndex)=>{
+        const rawX = series.xValues?.[sourceIndex] ?? sourceIndex + 1;
+        if (!Number.isFinite(rawX) || !Number.isFinite(rawY)) return [];
+        if (!requireBubbleSize) return [
+            {
+                x: rawX,
+                y: rawY,
+                sourceIndex
+            }
+        ];
+        const bubbleSize = series.bubbleSizes?.[sourceIndex];
+        if ('number' != typeof bubbleSize || !Number.isFinite(bubbleSize) || 0 === bubbleSize || !showNegativeBubbles && bubbleSize < 0) return [];
+        return [
+            {
+                x: rawX,
+                y: rawY,
+                sourceIndex,
+                bubbleSize
+            }
+        ];
+    });
+}
+function scatterSeriesSvg(chart, seriesPoints, pointX, pointY) {
+    const style = normalizeWorkSpreadsheetScatterStyle(chart.scatterStyle);
+    const showLine = 'marker' !== style;
+    const showMarkers = 'marker' === style || 'lineMarker' === style || 'smoothMarker' === style;
+    const smooth = 'smooth' === style || 'smoothMarker' === style;
+    const series = seriesPoints.map((points, seriesIndex)=>{
+        const sourceSeries = chart.series[seriesIndex];
+        const lineStyle = spreadsheetChartSeriesLineStyle(sourceSeries, seriesIndex, 2.3);
+        const positioned = points.map((point)=>({
+                ...point,
+                plotX: pointX(point.x),
+                plotY: pointY(point.y)
+            }));
+        const line = showLine && positioned.length > 1 ? `<path data-scatter-line="${seriesIndex}" d="${scatterPath(positioned, smooth)}" fill="none" ${lineStyle.attributes} stroke-linejoin="round" stroke-linecap="round"/>` : '';
+        const markers = positioned.map((point)=>spreadsheetChartSeriesMarkerSvg(sourceSeries, seriesIndex, point.plotX, point.plotY, {
+                visible: showMarkers,
+                defaultSize: 5.67,
+                attributes: `data-scatter-marker="${seriesIndex}:${point.sourceIndex}" data-point-x="${roundChartNumber(point.x)}" data-point-y="${roundChartNumber(point.y)}"`
+            })).join('');
+        const dataLabels = positioned.map((point)=>spreadsheetDataLabelSvg(chart, seriesIndex, point.sourceIndex, {
+                kind: 'point',
+                x: point.plotX,
+                y: point.plotY
+            })).join('');
+        return `<g data-scatter-series="${seriesIndex}">${line}${markers}${dataLabels}</g>`;
+    }).join('');
+    return `<g data-scatter-style="${style}">${series}</g>`;
+}
+function scatterPath(points, smooth) {
+    if (!points.length) return '';
+    if (!smooth || points.length < 3) return points.map((point, index)=>`${index ? 'L' : 'M'} ${roundChartNumber(point.plotX)} ${roundChartNumber(point.plotY)}`).join(' ');
+    const commands = [
+        `M ${roundChartNumber(points[0].plotX)} ${roundChartNumber(points[0].plotY)}`
+    ];
+    for(let index = 0; index < points.length - 1; index += 1){
+        const previous = points[index - 1] ?? points[index];
+        const current = points[index];
+        const next = points[index + 1];
+        const following = points[index + 2] ?? next;
+        const control1X = current.plotX + (next.plotX - previous.plotX) / 6;
+        const control1Y = current.plotY + (next.plotY - previous.plotY) / 6;
+        const control2X = next.plotX - (following.plotX - current.plotX) / 6;
+        const control2Y = next.plotY - (following.plotY - current.plotY) / 6;
+        commands.push(`C ${roundChartNumber(control1X)} ${roundChartNumber(control1Y)} ${roundChartNumber(control2X)} ${roundChartNumber(control2Y)} ${roundChartNumber(next.plotX)} ${roundChartNumber(next.plotY)}`);
+    }
+    return commands.join(' ');
+}
+function bubbleSeriesSvg(chart, seriesPoints, pointX, pointY) {
+    const scale = normalizeWorkSpreadsheetBubbleScale(chart.bubbleScale);
+    const sizeRepresents = normalizeWorkSpreadsheetBubbleSizeRepresents(chart.bubbleSizeRepresents);
+    const maximumSize = Math.max(1, ...seriesPoints.flatMap((points)=>points.map((point)=>Math.abs(point.bubbleSize ?? 0))));
+    const maximumRadius = Math.max(0, Math.min(54, scale / 100 * 18));
+    const series = seriesPoints.map((points, seriesIndex)=>{
+        const sourceSeries = chart.series[seriesIndex];
+        const sourceStyle = normalizeWorkSpreadsheetChartSeriesStyle(sourceSeries.style);
+        const fill = spreadsheetChartSeriesFillStyle(sourceSeries, seriesIndex, 0.34);
+        const line = spreadsheetChartSeriesLineStyle(sourceSeries, seriesIndex, 1.8);
+        const bubbles = points.map((point)=>{
+            const size = point.bubbleSize ?? 0;
+            const ratio = Math.abs(size) / maximumSize;
+            const radius = maximumRadius * ('area' === sizeRepresents ? Math.sqrt(ratio) : ratio);
+            const negative = size < 0;
+            const bubbleOpacity = sourceStyle?.fillTransparency === void 0 ? negative ? 0.2 : 0.34 : fill.opacity;
+            return `<circle data-bubble-point="${seriesIndex}:${point.sourceIndex}" data-point-x="${roundChartNumber(point.x)}" data-point-y="${roundChartNumber(point.y)}" data-bubble-size="${roundChartNumber(size)}" data-negative-bubble="${negative}" cx="${roundChartNumber(pointX(point.x))}" cy="${roundChartNumber(pointY(point.y))}" r="${roundChartNumber(radius)}" fill="${fill.color}" fill-opacity="${bubbleOpacity}" ${line.attributes}${negative && 'solid' === line.dash ? ' stroke-dasharray="3 2"' : ''}/>${spreadsheetDataLabelSvg(chart, seriesIndex, point.sourceIndex, {
+                kind: 'point',
+                x: pointX(point.x),
+                y: pointY(point.y) - radius
+            })}`;
+        }).join('');
+        return `<g data-bubble-series="${seriesIndex}">${bubbles}</g>`;
+    }).join('');
+    return `<g data-bubble-scale="${scale}" data-show-negative-bubbles="${true === chart.showNegativeBubbles}" data-bubble-size-represents="${sizeRepresents}">${series}</g>`;
+}
+function cartesianChartSvg(chart, plot) {
+    const layout = spreadsheetChartSeriesLayout(chart);
+    const trendlineValues = layout.stacked ? [] : chart.series.flatMap((series)=>spreadsheetSeriesTrendlineFits(series, categoryTrendlineXValues(series)).flatMap((item)=>item.fit.points.map((point)=>point.y)));
+    const values = [
+        ...layout.scaleValues,
+        ...layout.stacked ? [] : chart.series.flatMap((series)=>spreadsheetSeriesErrorBarBounds(series, chart.type, 'y')),
+        ...trendlineValues
+    ];
+    if (!values.length) return emptyChartSvg(plot, '没有可绘制的数据');
+    if ('bar' === chart.type) return horizontalBarChartSvg(chart, plot, layout, values);
+    const axis = chart.axes?.left;
+    const scale = spreadsheetChartAxisScale(values, axis, {
+        includeZero: true
+    });
+    const valuePosition = (value)=>plot.y + (1 - spreadsheetChartAxisValueRatio(value, scale, axis)) * plot.height;
+    const baseline = valuePosition(0);
+    const numberFormat = axis?.numberFormat ?? ('percentStacked' === layout.grouping ? '0%' : void 0);
+    const showGridlines = spreadsheetChartAxisGridlinesVisible(axis, chart.type, 'left');
+    const grid = scale.ticks.map((value, index)=>{
+        const y = valuePosition(value);
+        const label = spreadsheetChartAxisLabelLayout(axis, chart.type, 'left', plot, plot.x, y);
+        return `${showGridlines ? `<line x1="${plot.x}" y1="${roundChartNumber(y)}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(y)}" stroke="#e8ebf0" stroke-width="1"/>` : ''}${spreadsheetChartMajorTickSvg(axis, 'left', index, plot.x, y)}${label ? `<text data-axis-tick="left" x="${roundChartNumber(label.x)}" y="${roundChartNumber(label.y)}" fill="#717b8f" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${label.textAnchor}">${escapeChartXml(formatSpreadsheetChartAxisNumber(value, numberFormat))}</text>` : ''}`;
+    }).join('');
+    const axes = [
+        `<g ${spreadsheetChartAxisScaleAttributes(axis, scale, chart.type, 'left')}>${grid}<line x1="${plot.x}" y1="${plot.y}" x2="${plot.x}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#aeb6c4" stroke-width="1.2"/></g>`,
+        `<g ${spreadsheetChartAxisDisplayAttributes(chart.axes?.bottom, chart.type, 'bottom')}><line x1="${plot.x}" y1="${roundChartNumber(baseline)}" x2="${roundChartNumber(plot.x + plot.width)}" y2="${roundChartNumber(baseline)}" stroke="#aeb6c4" stroke-width="1.2"/></g>`
+    ].join('');
+    const trendlines = layout.stacked ? '' : cartesianTrendlinesSvg(chart, plot, valuePosition);
+    if ('line' === chart.type || 'area' === chart.type) return `${axes}${spreadsheetLineChartSvg(chart, plot, valuePosition, layout)}${trendlines}${categoryLabelsSvg(chart, plot, baseline)}`;
+    return `${axes}${barChartSvg(chart, plot, valuePosition, baseline, layout)}${trendlines}${categoryLabelsSvg(chart, plot, baseline)}`;
+}
+function cartesianTrendlinesSvg(chart, plot, valuePosition) {
+    const categoryCount = Math.max(1, chart.categories.length, ...chart.series.map((series)=>series.values.length));
+    const categoryAxis = chart.axes?.bottom;
+    const categoryPosition = (value)=>1 === categoryCount ? plot.x + plot.width / 2 : plot.x + spreadsheetChartCategoryVisualIndex(value - 1, categoryCount, categoryAxis) / Math.max(1, categoryCount - 1) * plot.width;
+    return chart.series.map((series, seriesIndex)=>spreadsheetSeriesTrendlinesSvg(series, seriesIndex, categoryTrendlineXValues(series), (x, y)=>[
+                categoryPosition(x),
+                valuePosition(y)
+            ])).join('');
+}
+function categoryTrendlineXValues(series) {
+    return series.values.map((_, index)=>index + 1);
+}
+function barChartSvg(chart, plot, valuePosition, baseline, layout) {
+    const categoryCount = layout.categoryCount;
+    const seriesCount = Math.max(1, chart.series.length);
+    const groupWidth = plot.width / categoryCount;
+    const categoryAxis = chart.axes?.bottom;
+    const geometry = spreadsheetChartBarGeometry(groupWidth, seriesCount, chart, 44);
+    return layout.series.map((points, seriesIndex)=>{
+        const seriesX = (pointIndex)=>plot.x + spreadsheetChartCategoryVisualIndex(pointIndex, categoryCount, categoryAxis) * groupWidth + geometry.offset(seriesIndex);
+        const renderedWidth = geometry.renderedSize;
+        const bars = points.map((point)=>{
+            const startY = layout.stacked ? valuePosition(point.start) : baseline;
+            const endY = valuePosition(point.end);
+            const x = seriesX(point.categoryIndex);
+            return `<rect data-chart-bar="${seriesIndex}:${point.categoryIndex}" data-stack-start="${roundChartNumber(point.start)}" data-stack-end="${roundChartNumber(point.end)}" x="${roundChartNumber(x)}" y="${roundChartNumber(Math.min(endY, startY))}" width="${roundChartNumber(renderedWidth)}" height="${roundChartNumber(Math.max(1, Math.abs(endY - startY)))}" rx="1.5" ${spreadsheetChartSeriesFillStyle(chart.series[seriesIndex], seriesIndex).attributes} ${spreadsheetChartSeriesLineStyle(chart.series[seriesIndex], seriesIndex, 0).attributes}/>${spreadsheetDataLabelSvg(chart, seriesIndex, point.categoryIndex, {
+                kind: 'verticalBar',
+                x: x + renderedWidth / 2,
+                valueY: endY,
+                baselineY: startY,
+                value: point.rawValue
+            })}`;
+        }).join('');
+        const errorBars = layout.stacked ? '' : spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, (_direction, pointIndex, value)=>[
+                seriesX(pointIndex) + renderedWidth / 2,
+                valuePosition(value)
+            ]);
+        return `${bars}${errorBars}`;
+    }).join('');
+}
+function horizontalBarChartSvg(chart, plot, layout, values) {
+    const axis = chart.axes?.bottom;
+    const scale = spreadsheetChartAxisScale(values, axis, {
+        includeZero: true
+    });
+    const valuePosition = (value)=>plot.x + spreadsheetChartAxisValueRatio(value, scale, axis) * plot.width;
+    const zero = valuePosition(0);
+    const categoryCount = layout.categoryCount;
+    const seriesCount = Math.max(1, chart.series.length);
+    const groupHeight = plot.height / categoryCount;
+    const geometry = spreadsheetChartBarGeometry(groupHeight, seriesCount, chart, 30);
+    const categoryAxis = chart.axes?.left;
+    const numberFormat = axis?.numberFormat ?? ('percentStacked' === layout.grouping ? '0%' : void 0);
+    const showGridlines = spreadsheetChartAxisGridlinesVisible(axis, chart.type, 'bottom');
+    const grid = scale.ticks.map((value, index)=>{
+        const x = valuePosition(value);
+        const label = spreadsheetChartAxisLabelLayout(axis, chart.type, 'bottom', plot, x, plot.y + plot.height);
+        return `${showGridlines ? `<line x1="${roundChartNumber(x)}" y1="${plot.y}" x2="${roundChartNumber(x)}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#e8ebf0" stroke-width="1"/>` : ''}${spreadsheetChartMajorTickSvg(axis, 'bottom', index, x, plot.y + plot.height)}${label ? `<text data-axis-tick="bottom" x="${roundChartNumber(label.x)}" y="${roundChartNumber(label.y)}" fill="#717b8f" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${label.textAnchor}">${escapeChartXml(formatSpreadsheetChartAxisNumber(value, numberFormat))}</text>` : ''}`;
+    }).join('');
+    const labels = Array.from({
+        length: categoryCount
+    }, (_, index)=>{
+        const visible = spreadsheetChartCategoryLabelVisible(index, categoryCount, categoryAxis);
+        const label = chart.categories[index] ?? String(index + 1);
+        const visualIndex = spreadsheetChartCategoryVisualIndex(index, categoryCount, categoryAxis);
+        const y = plot.y + (visualIndex + 0.5) * groupHeight;
+        const labelLayout = spreadsheetChartAxisLabelLayout(categoryAxis, chart.type, 'left', plot, zero, y);
+        return `${spreadsheetChartMajorTickSvg(categoryAxis, 'left', index, zero, y)}${visible && labelLayout ? `<text data-axis-category-label="${index}" x="${roundChartNumber(labelLayout.x)}" y="${roundChartNumber(labelLayout.y)}" fill="#536078" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${labelLayout.textAnchor}">${escapeChartXml(truncateChartText(label, 11))}</text>` : ''}`;
+    }).join('');
+    const bars = layout.series.map((points, seriesIndex)=>{
+        const seriesY = (pointIndex)=>plot.y + spreadsheetChartCategoryVisualIndex(pointIndex, categoryCount, categoryAxis) * groupHeight + geometry.offset(seriesIndex);
+        const renderedHeight = geometry.renderedSize;
+        const fill = spreadsheetChartSeriesFillStyle(chart.series[seriesIndex], seriesIndex);
+        const line = spreadsheetChartSeriesLineStyle(chart.series[seriesIndex], seriesIndex, 0);
+        const seriesBars = points.map((point)=>{
+            const startX = layout.stacked ? valuePosition(point.start) : zero;
+            const endX = valuePosition(point.end);
+            const y = seriesY(point.categoryIndex);
+            return `<rect data-chart-bar="${seriesIndex}:${point.categoryIndex}" data-stack-start="${roundChartNumber(point.start)}" data-stack-end="${roundChartNumber(point.end)}" x="${roundChartNumber(Math.min(endX, startX))}" y="${roundChartNumber(y)}" width="${roundChartNumber(Math.max(1, Math.abs(endX - startX)))}" height="${roundChartNumber(renderedHeight)}" rx="1.5" ${fill.attributes} ${line.attributes}/>${spreadsheetDataLabelSvg(chart, seriesIndex, point.categoryIndex, {
+                kind: 'horizontalBar',
+                y: y + renderedHeight / 2,
+                valueX: endX,
+                baselineX: startX,
+                value: point.rawValue
+            })}`;
+        }).join('');
+        const errorBars = layout.stacked ? '' : spreadsheetSeriesErrorBarsSvg(chart, seriesIndex, (_direction, pointIndex, value)=>[
+                valuePosition(value),
+                seriesY(pointIndex) + renderedHeight / 2
+            ]);
+        return `${seriesBars}${errorBars}`;
+    }).join('');
+    const trendlines = layout.stacked ? '' : chart.series.map((series, seriesIndex)=>spreadsheetSeriesTrendlinesSvg(series, seriesIndex, categoryTrendlineXValues(series), (category, value)=>[
+                valuePosition(value),
+                plot.y + (spreadsheetChartCategoryVisualIndex(category - 1, categoryCount, categoryAxis) + 0.5) / categoryCount * plot.height
+            ])).join('');
+    return `<g ${spreadsheetChartAxisScaleAttributes(axis, scale, chart.type, 'bottom')}>${grid}<line x1="${roundChartNumber(zero)}" y1="${plot.y}" x2="${roundChartNumber(zero)}" y2="${roundChartNumber(plot.y + plot.height)}" stroke="#aeb6c4" stroke-width="1.2"/></g><g ${spreadsheetChartAxisDisplayAttributes(categoryAxis, chart.type, 'left')}>${labels}</g>${bars}${trendlines}`;
+}
+function categoryLabelsSvg(chart, plot, axisY) {
+    const categoryCount = Math.max(1, chart.categories.length, ...chart.series.map((series)=>series.values.length));
+    const axis = chart.axes?.bottom;
+    const labels = Array.from({
+        length: categoryCount
+    }, (_, index)=>{
+        const visible = spreadsheetChartCategoryLabelVisible(index, categoryCount, axis);
+        const label = chart.categories[index] ?? String(index + 1);
+        const visualIndex = spreadsheetChartCategoryVisualIndex(index, categoryCount, axis);
+        const x = plot.x + (visualIndex + 0.5) / categoryCount * plot.width;
+        const labelLayout = spreadsheetChartAxisLabelLayout(axis, chart.type, 'bottom', plot, x, axisY);
+        return `${spreadsheetChartMajorTickSvg(axis, 'bottom', index, x, axisY)}${visible && labelLayout ? `<text data-axis-category-label="${index}" x="${roundChartNumber(labelLayout.x)}" y="${roundChartNumber(labelLayout.y)}" fill="#536078" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="10" text-anchor="${labelLayout.textAnchor}">${escapeChartXml(truncateChartText(label, 13))}</text>` : ''}`;
+    }).join('');
+    return `<g ${spreadsheetChartAxisDisplayAttributes(axis, chart.type, 'bottom')}>${labels}</g>`;
+}
+function emptyChartSvg(plot, message) {
+    return `<text x="${roundChartNumber(plot.x + plot.width / 2)}" y="${roundChartNumber(plot.y + plot.height / 2)}" fill="#8791a3" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif" font-size="13" text-anchor="middle">${escapeChartXml(message)}</text>`;
+}
+const XLSX_EMU_PER_PIXEL = 9525;
+const DEFAULT_COLUMN_WIDTH = 96;
+const DEFAULT_ROW_HEIGHT = 24;
+function readXlsxDrawingAnchor(anchor) {
+    const extent = directChild(anchor, 'ext');
+    const position = directChild(anchor, 'pos');
+    return {
+        from: readMarker(directChild(anchor, 'from')),
+        to: readMarker(directChild(anchor, 'to')),
+        leftEmu: numberAttribute(position, 'x'),
+        topEmu: numberAttribute(position, 'y'),
+        widthEmu: numberAttribute(extent, 'cx'),
+        heightEmu: numberAttribute(extent, 'cy')
+    };
+}
+function xlsxDrawingAnchorToBounds(anchor, config) {
+    const left = anchor.from ? markerPosition(anchor.from.column, anchor.from.columnOffsetEmu, (index)=>spreadsheetColumnWidth(config, index)) : emuToPixels(anchor.leftEmu);
+    const top = anchor.from ? markerPosition(anchor.from.row, anchor.from.rowOffsetEmu, (index)=>spreadsheetRowHeight(config, index)) : emuToPixels(anchor.topEmu);
+    const right = anchor.to ? markerPosition(anchor.to.column, anchor.to.columnOffsetEmu, (index)=>spreadsheetColumnWidth(config, index)) : left + emuToPixels(anchor.widthEmu);
+    const bottom = anchor.to ? markerPosition(anchor.to.row, anchor.to.rowOffsetEmu, (index)=>spreadsheetRowHeight(config, index)) : top + emuToPixels(anchor.heightEmu);
+    if (![
+        left,
+        top,
+        right,
+        bottom
+    ].every(Number.isFinite)) return null;
+    return {
+        left: roundPosition(Math.max(0, left)),
+        top: roundPosition(Math.max(0, top)),
+        width: roundPosition(Math.max(1, right - left)),
+        height: roundPosition(Math.max(1, bottom - top))
+    };
+}
+function xlsxTwoCellAnchorMarkers(bounds, sheet) {
+    const fromColumn = axisMarker(bounds.left, (index)=>spreadsheetColumnWidth(sheet.config, index));
+    const toColumn = axisMarker(bounds.left + bounds.width, (index)=>spreadsheetColumnWidth(sheet.config, index));
+    const fromRow = axisMarker(bounds.top, (index)=>spreadsheetRowHeight(sheet.config, index));
+    const toRow = axisMarker(bounds.top + bounds.height, (index)=>spreadsheetRowHeight(sheet.config, index));
+    return `${markerXml('from', fromColumn, fromRow)}${markerXml('to', toColumn, toRow)}`;
+}
+function spreadsheetColumnWidth(config, index) {
+    const key = String(index);
+    if (Object.hasOwn(config?.colhidden ?? {}, key)) return 0;
+    const width = config?.columnlen?.[key];
+    return 'number' == typeof width && width > 0 ? width : DEFAULT_COLUMN_WIDTH;
+}
+function spreadsheetRowHeight(config, index) {
+    const key = String(index);
+    if (Object.hasOwn(config?.rowhidden ?? {}, key)) return 0;
+    const height = config?.rowlen?.[key];
+    return 'number' == typeof height && height > 0 ? height : DEFAULT_ROW_HEIGHT;
+}
+function readMarker(element) {
+    if (!element) return;
+    return {
+        column: nonNegativeInteger(directChild(element, 'col')?.textContent),
+        row: nonNegativeInteger(directChild(element, 'row')?.textContent),
+        columnOffsetEmu: nonNegativeNumber(directChild(element, 'colOff')?.textContent),
+        rowOffsetEmu: nonNegativeNumber(directChild(element, 'rowOff')?.textContent)
+    };
+}
+function numberAttribute(element, name) {
+    if (!element) return;
+    const value = Number(attribute(element, name));
+    return Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function nonNegativeInteger(value) {
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+function nonNegativeNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+function markerPosition(index, offsetEmu, size) {
+    let position = 0;
+    for(let current = 0; current < index; current += 1)position += size(current);
+    return position + emuToPixels(offsetEmu);
+}
+function emuToPixels(value) {
+    return (value ?? 0) / XLSX_EMU_PER_PIXEL;
+}
+function axisMarker(position, size) {
+    let remaining = Math.max(0, Number.isFinite(position) ? position : 0);
+    let index = 0;
+    while(index < 1048576){
+        const currentSize = Math.max(0, size(index));
+        if (currentSize > 0 && remaining < currentSize) break;
+        if (currentSize > 0) remaining -= currentSize;
+        index += 1;
+    }
+    return {
+        index,
+        offsetEmu: Math.round(remaining * XLSX_EMU_PER_PIXEL)
+    };
+}
+function markerXml(kind, column, row) {
+    return [
+        `<xdr:${kind}>`,
+        `<xdr:col>${column.index}</xdr:col><xdr:colOff>${column.offsetEmu}</xdr:colOff>`,
+        `<xdr:row>${row.index}</xdr:row><xdr:rowOff>${row.offsetEmu}</xdr:rowOff>`,
+        `</xdr:${kind}>`
+    ].join('');
+}
+function roundPosition(value) {
+    return Math.round(1000 * value) / 1000;
+}
+const CHART_PREVIEW_IMAGE_PREFIX = 'work-chart-preview-';
+function spreadsheetChartCount(content) {
+    return content.sheets.reduce((count, sheet)=>count + (sheet.charts?.length ?? 0), 0);
+}
+function spreadsheetSheetsWithChartPreviews(content) {
+    return content.sheets.map((sheet)=>{
+        const chartImages = (sheet.charts ?? []).map((chart)=>chartPreviewImage(resolveSpreadsheetChart(content, sheet, chart)));
+        if (!chartImages.length) return sheet;
+        return {
+            ...sheet,
+            images: [
+                ...sheet.images ?? [],
+                ...chartImages
+            ]
+        };
+    });
+}
+function reconcileSpreadsheetChartPreviews(content, changedSheets) {
+    const sourceById = new Map(content.sheets.flatMap((sheet)=>sheet.id ? [
+            [
+                sheet.id,
+                sheet
+            ]
+        ] : []));
+    const renamedSheets = new Map(changedSheets.flatMap((sheet)=>{
+        const sourceName = sheet.id ? sourceById.get(sheet.id)?.name : void 0;
+        return sourceName && sourceName !== sheet.name ? [
+            [
+                sourceName,
+                sheet.name
+            ]
+        ] : [];
+    }));
+    const sheets = changedSheets.map((changedSheet)=>{
+        const source = (changedSheet.id ? sourceById.get(changedSheet.id) : void 0) ?? changedSheet;
+        const previewImages = new Map((changedSheet.images ?? []).filter((image)=>image.id.startsWith(CHART_PREVIEW_IMAGE_PREFIX)).map((image)=>[
+                image.id,
+                image
+            ]));
+        const charts = (source.charts ?? []).flatMap((sourceChart)=>{
+            const chart = renameSpreadsheetChartReferences(sourceChart, renamedSheets);
+            const preview = previewImages.get(chartPreviewImageId(chart.id));
+            if (!preview) return [];
+            return [
+                {
+                    ...chart,
+                    left: finiteDimension(preview.left, chart.left),
+                    top: finiteDimension(preview.top, chart.top),
+                    width: finiteDimension(preview.width, chart.width, 1),
+                    height: finiteDimension(preview.height, chart.height, 1)
+                }
+            ];
+        });
+        const images = (changedSheet.images ?? []).filter((image)=>!image.id.startsWith(CHART_PREVIEW_IMAGE_PREFIX));
+        return {
+            ...changedSheet,
+            images: images.length ? images : void 0,
+            charts: charts.length ? charts : void 0,
+            ...changedSheet.formulaMetadata ?? source.formulaMetadata ? {
+                formulaMetadata: changedSheet.formulaMetadata ?? source.formulaMetadata
+            } : {}
+        };
+    });
+    return {
+        ...content,
+        sheets
+    };
+}
+function resolveSpreadsheetChart(content, ownerSheet, chart) {
+    const titleValue = chart.titleReference ? spreadsheetReferenceValues(content, ownerSheet, chart.titleReference)?.[0] : void 0;
+    const categories = chart.categoryReference ? spreadsheetReferenceValues(content, ownerSheet, chart.categoryReference)?.map(displayCellValue) : void 0;
+    const series = chart.series.map((item)=>resolveSpreadsheetChartSeries(content, ownerSheet, item));
+    const axes = resolveSpreadsheetChartAxes(content, ownerSheet, chart.axes);
+    return {
+        ...chart,
+        title: void 0 === titleValue ? chart.title : displayCellValue(titleValue),
+        categories: categories ?? chart.categories,
+        series,
+        ...axes ? {
+            axes
+        } : {}
+    };
+}
+function createSpreadsheetChartFromSelection(content, sheetId, selection) {
+    const sheet = content.sheets.find((candidate)=>candidate.id === sheetId);
+    if (!sheet) return null;
+    const bounds = normalizedSelection(selection ?? sheet.luckysheet_select_save?.at(-1));
+    if (!bounds) return null;
+    const rowCount = bounds.endRow - bounds.startRow + 1;
+    const columnCount = bounds.endColumn - bounds.startColumn + 1;
+    const hasHeader = rowCount > 1 && selectionHasHeader(sheet, bounds);
+    const dataStartRow = hasHeader ? bounds.startRow + 1 : bounds.startRow;
+    const chartNumber = spreadsheetChartCount(content) + 1;
+    const chartName = `图表 ${chartNumber}`;
+    let categoryReference;
+    let categories;
+    let series;
+    if (columnCount > 1) {
+        categoryReference = cellRangeFormula(sheet.name, dataStartRow, bounds.startColumn, bounds.endRow, bounds.startColumn);
+        categories = rangeValues(sheet, dataStartRow, bounds.startColumn, bounds.endRow, bounds.startColumn).map(displayCellValue);
+        series = inclusiveNumbers(bounds.startColumn + 1, bounds.endColumn).map((column, index)=>({
+                name: hasHeader ? displayCellValue(sheet.data?.[bounds.startRow]?.[column]?.v ?? `系列 ${index + 1}`) : `系列 ${index + 1}`,
+                nameReference: hasHeader ? cellRangeFormula(sheet.name, bounds.startRow, column, bounds.startRow, column) : void 0,
+                valuesReference: cellRangeFormula(sheet.name, dataStartRow, column, bounds.endRow, column),
+                values: rangeValues(sheet, dataStartRow, column, bounds.endRow, column).map(numericCellValue)
+            }));
+    } else {
+        categories = inclusiveNumbers(dataStartRow, bounds.endRow).map((row)=>String(row + 1));
+        series = [
+            {
+                name: hasHeader ? displayCellValue(sheet.data?.[bounds.startRow]?.[bounds.startColumn]?.v ?? '系列 1') : '系列 1',
+                nameReference: hasHeader ? cellRangeFormula(sheet.name, bounds.startRow, bounds.startColumn, bounds.startRow, bounds.startColumn) : void 0,
+                valuesReference: cellRangeFormula(sheet.name, dataStartRow, bounds.startColumn, bounds.endRow, bounds.startColumn),
+                values: rangeValues(sheet, dataStartRow, bounds.startColumn, bounds.endRow, bounds.startColumn).map(numericCellValue)
+            }
+        ];
+    }
+    const left = axisPosition(bounds.endColumn + 1, (index)=>spreadsheetColumnWidth(sheet.config, index)) + 16;
+    const top = axisPosition(bounds.startRow, (index)=>spreadsheetRowHeight(sheet.config, index));
+    return {
+        id: createWorkId('chart'),
+        name: chartName,
+        altText: `${chartName}，来源于 ${sheet.name} 的当前选区`,
+        type: 'column',
+        title: chartName,
+        categories,
+        categoryReference,
+        series,
+        showLegend: series.length > 1,
+        legendPosition: 'right',
+        legendOverlay: false,
+        grouping: 'clustered',
+        gapWidth: 150,
+        overlap: 0,
+        left,
+        top,
+        width: 480,
+        height: 288
+    };
+}
+function parseSpreadsheetChartReference(content, ownerSheet, reference) {
+    const formula = reference.trim().replace(/^=/, '');
+    const match = /^(?:(?:'((?:[^']|'')+)'|([^!]+))!)?(\$?[A-Z]{1,3}\$?[1-9]\d*)(?::(\$?[A-Z]{1,3}\$?[1-9]\d*))?$/i.exec(formula);
+    if (!match) return null;
+    const sheetName = (match[1]?.replaceAll("''", "'") ?? match[2])?.trim();
+    if (sheetName?.includes('[') || sheetName?.includes(']')) return null;
+    const sheet = sheetName ? content.sheets.find((candidate)=>candidate.name === sheetName) : ownerSheet;
+    if (!sheet) return null;
+    const start = decodeCellAddress(match[3]);
+    const end = decodeCellAddress(match[4] ?? match[3]);
+    if (!start || !end) return null;
+    return {
+        sheet,
+        startRow: Math.min(start.row, end.row),
+        endRow: Math.max(start.row, end.row),
+        startColumn: Math.min(start.column, end.column),
+        endColumn: Math.max(start.column, end.column)
+    };
+}
+function spreadsheetReferenceValues(content, ownerSheet, reference) {
+    const range = parseSpreadsheetChartReference(content, ownerSheet, reference);
+    if (!range) return;
+    return rangeValues(range.sheet, range.startRow, range.startColumn, range.endRow, range.endColumn);
+}
+function quoteSpreadsheetSheetName(name) {
+    return /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) ? name : `'${name.replaceAll("'", "''")}'`;
+}
+function renameSpreadsheetChartReferences(chart, renamedSheets) {
+    if (!renamedSheets.size) return chart;
+    return {
+        ...chart,
+        titleReference: renameSpreadsheetReference(chart.titleReference, renamedSheets),
+        axes: renameSpreadsheetChartAxesReferences(chart.axes, renamedSheets),
+        categoryReference: renameSpreadsheetReference(chart.categoryReference, renamedSheets),
+        series: chart.series.map((series)=>({
+                ...series,
+                nameReference: renameSpreadsheetReference(series.nameReference, renamedSheets),
+                valuesReference: renameSpreadsheetReference(series.valuesReference, renamedSheets),
+                xValuesReference: renameSpreadsheetReference(series.xValuesReference, renamedSheets),
+                bubbleSizesReference: renameSpreadsheetReference(series.bubbleSizesReference, renamedSheets),
+                ...series.errorBars ? {
+                    errorBars: series.errorBars.map((errorBars)=>({
+                            ...errorBars,
+                            plusReference: renameSpreadsheetReference(errorBars.plusReference, renamedSheets),
+                            minusReference: renameSpreadsheetReference(errorBars.minusReference, renamedSheets)
+                        }))
+                } : {}
+            }))
+    };
+}
+function renameSpreadsheetChartAxesReferences(axes, renamedSheets) {
+    if (!axes) return;
+    const bottom = renameSpreadsheetChartAxisReference(axes.bottom, renamedSheets);
+    const left = renameSpreadsheetChartAxisReference(axes.left, renamedSheets);
+    const top = renameSpreadsheetChartAxisReference(axes.top, renamedSheets);
+    const right = renameSpreadsheetChartAxisReference(axes.right, renamedSheets);
+    return {
+        ...bottom ? {
+            bottom
+        } : {},
+        ...left ? {
+            left
+        } : {},
+        ...top ? {
+            top
+        } : {},
+        ...right ? {
+            right
+        } : {}
+    };
+}
+function renameSpreadsheetChartAxisReference(axis, renamedSheets) {
+    return axis ? {
+        ...axis,
+        titleReference: renameSpreadsheetReference(axis.titleReference, renamedSheets)
+    } : void 0;
+}
+function renameSpreadsheetReference(reference, renamedSheets) {
+    if (!reference) return;
+    const formula = reference.trim().replace(/^=/, '');
+    const match = /^(?:'((?:[^']|'')+)'|([^!]+))!(.+)$/.exec(formula);
+    const sheetName = match ? match[1]?.replaceAll("''", "'") ?? match[2] : void 0;
+    const renamed = sheetName ? renamedSheets.get(sheetName) : void 0;
+    return renamed && match ? `${quoteSpreadsheetSheetName(renamed)}!${match[3]}` : formula;
+}
+function resolveSpreadsheetChartSeries(content, ownerSheet, series) {
+    const nameValue = series.nameReference ? spreadsheetReferenceValues(content, ownerSheet, series.nameReference)?.[0] : void 0;
+    const values = series.valuesReference ? spreadsheetReferenceValues(content, ownerSheet, series.valuesReference)?.map(numericCellValue) : void 0;
+    const xValues = series.xValuesReference ? spreadsheetReferenceValues(content, ownerSheet, series.xValuesReference)?.map(numericCellValue) : void 0;
+    const bubbleSizes = series.bubbleSizesReference ? spreadsheetReferenceValues(content, ownerSheet, series.bubbleSizesReference)?.map(numericCellValue) : void 0;
+    const errorBars = series.errorBars?.map((source)=>({
+            ...source,
+            plusValues: source.plusReference ? spreadsheetReferenceValues(content, ownerSheet, source.plusReference)?.map(numericCellValue) ?? source.plusValues : source.plusValues,
+            minusValues: source.minusReference ? spreadsheetReferenceValues(content, ownerSheet, source.minusReference)?.map(numericCellValue) ?? source.minusValues : source.minusValues
+        }));
+    return {
+        ...series,
+        name: void 0 === nameValue ? series.name : displayCellValue(nameValue),
+        values: values ?? series.values,
+        xValues: xValues ?? series.xValues,
+        bubbleSizes: bubbleSizes ?? series.bubbleSizes,
+        ...errorBars ? {
+            errorBars
+        } : {}
+    };
+}
+function resolveSpreadsheetChartAxes(content, ownerSheet, axes) {
+    if (!axes) return;
+    const bottom = resolveSpreadsheetChartAxis(content, ownerSheet, axes.bottom);
+    const left = resolveSpreadsheetChartAxis(content, ownerSheet, axes.left);
+    const top = resolveSpreadsheetChartAxis(content, ownerSheet, axes.top);
+    const right = resolveSpreadsheetChartAxis(content, ownerSheet, axes.right);
+    return {
+        ...bottom ? {
+            bottom
+        } : {},
+        ...left ? {
+            left
+        } : {},
+        ...top ? {
+            top
+        } : {},
+        ...right ? {
+            right
+        } : {}
+    };
+}
+function resolveSpreadsheetChartAxis(content, ownerSheet, axis) {
+    if (!axis) return;
+    const titleValue = axis.titleReference ? spreadsheetReferenceValues(content, ownerSheet, axis.titleReference)?.[0] : void 0;
+    return {
+        ...axis,
+        title: void 0 === titleValue ? axis.title : displayCellValue(titleValue)
+    };
+}
+function chartPreviewImage(chart) {
+    return {
+        id: chartPreviewImageId(chart.id),
+        name: chart.name,
+        altText: chart.altText ?? chart.title ?? chart.name,
+        contentType: 'image/svg+xml',
+        src: spreadsheetChartSvgDataUrl(chart),
+        left: chart.left,
+        top: chart.top,
+        width: chart.width,
+        height: chart.height
+    };
+}
+function chartPreviewImageId(chartId) {
+    return `${CHART_PREVIEW_IMAGE_PREFIX}${chartId}`;
+}
+function rangeValues(sheet, startRow, startColumn, endRow, endColumn) {
+    const values = [];
+    for(let row = startRow; row <= endRow; row += 1)for(let column = startColumn; column <= endColumn; column += 1){
+        const cell = sheet.data?.[row]?.[column];
+        values.push(cell?.v ?? cell?.m ?? '');
+    }
+    return values;
+}
+function selectionHasHeader(sheet, bounds) {
+    const seriesStartColumn = bounds.endColumn > bounds.startColumn ? bounds.startColumn + 1 : bounds.startColumn;
+    const firstRowValues = rangeValues(sheet, bounds.startRow, seriesStartColumn, bounds.startRow, bounds.endColumn);
+    const bodyValues = rangeValues(sheet, bounds.startRow + 1, seriesStartColumn, bounds.endRow, bounds.endColumn);
+    return firstRowValues.some((value)=>String(value ?? '').trim() && !isNumericValue(value)) && bodyValues.some(isNumericValue);
+}
+function normalizedSelection(selection) {
+    if (!selection) return null;
+    const startRow = Math.max(0, Math.min(selection.row[0], selection.row[1]));
+    const endRow = Math.max(startRow, Math.max(selection.row[0], selection.row[1]));
+    const startColumn = Math.max(0, Math.min(selection.column[0], selection.column[1]));
+    const endColumn = Math.max(startColumn, Math.max(selection.column[0], selection.column[1]));
+    if (![
+        startRow,
+        endRow,
+        startColumn,
+        endColumn
+    ].every(Number.isSafeInteger)) return null;
+    return {
+        startRow,
+        endRow,
+        startColumn,
+        endColumn
+    };
+}
+function cellRangeFormula(sheetName, startRow, startColumn, endRow, endColumn) {
+    const start = absoluteCellAddress(startRow, startColumn);
+    const end = absoluteCellAddress(endRow, endColumn);
+    return `${quoteSpreadsheetSheetName(sheetName)}!${start}${start === end ? '' : `:${end}`}`;
+}
+function absoluteCellAddress(row, column) {
+    return `$${columnName(column)}$${row + 1}`;
+}
+function decodeCellAddress(address) {
+    const match = /^\$?([A-Z]{1,3})\$?([1-9]\d*)$/i.exec(address);
+    if (!match) return null;
+    let column = 0;
+    for (const character of match[1].toUpperCase())column = 26 * column + character.charCodeAt(0) - 64;
+    const row = Number(match[2]);
+    if (column < 1 || column > 16384 || row < 1 || row > 1048576) return null;
+    return {
+        row: row - 1,
+        column: column - 1
+    };
+}
+function columnName(index) {
+    let value = index + 1;
+    let result = '';
+    while(value > 0){
+        value -= 1;
+        result = String.fromCharCode(65 + value % 26) + result;
+        value = Math.floor(value / 26);
+    }
+    return result;
+}
+function axisPosition(index, size) {
+    let position = 0;
+    for(let current = 0; current < index; current += 1)position += size(current);
+    return position;
+}
+function inclusiveNumbers(start, end) {
+    return Array.from({
+        length: Math.max(0, end - start + 1)
+    }, (_, index)=>start + index);
+}
+function displayCellValue(value) {
+    if (value instanceof Date) return value.toLocaleDateString('zh-CN');
+    if (null == value) return '';
+    return String(value);
+}
+function numericCellValue(value) {
+    if (value instanceof Date) return value.getTime();
+    const number = 'number' == typeof value ? value : Number(value);
+    return Number.isFinite(number) ? number : 0;
+}
+function isNumericValue(value) {
+    if (value instanceof Date || 'number' == typeof value) return true;
+    if ('string' != typeof value || !value.trim()) return false;
+    return Number.isFinite(Number(value));
+}
+function finiteDimension(value, fallback, minimum = 0) {
+    return Number.isFinite(value) ? Math.max(minimum, value) : fallback;
+}
+const DEFAULT_SPREADSHEET_CALCULATION_SETTINGS = {
+    mode: 'automatic',
+    fullCalculationOnLoad: false,
+    forceFullCalculation: false,
+    iterativeCalculation: false,
+    maximumIterations: 100,
+    maximumChange: 0.001,
+    fullPrecision: true
+};
+const VOLATILE_FUNCTIONS = new Set([
+    'CELL',
+    'INFO',
+    'INDIRECT',
+    'NOW',
+    'OFFSET',
+    'RAND',
+    'RANDBETWEEN',
+    'TODAY'
+]);
+const FUTURE_FUNCTIONS = new Set([
+    'ARRAYTOTEXT',
+    'BYCOL',
+    'BYROW',
+    'CHOOSECOLS',
+    'CHOOSEROWS',
+    'DROP',
+    'EXPAND',
+    'FIELDVALUE',
+    'FILTER',
+    'HSTACK',
+    'IMAGE',
+    'ISOMITTED',
+    'LAMBDA',
+    'LET',
+    'MAKEARRAY',
+    'MAP',
+    'RANDARRAY',
+    'REDUCE',
+    'SCAN',
+    'SEQUENCE',
+    'SORT',
+    'SORTBY',
+    'STOCKHISTORY',
+    'TAKE',
+    'TEXTAFTER',
+    'TEXTBEFORE',
+    'TEXTSPLIT',
+    'TOCOL',
+    'TOROW',
+    'UNIQUE',
+    'VALUETOTEXT',
+    'VSTACK',
+    'WRAPCOLS',
+    'WRAPROWS',
+    'XLOOKUP',
+    'XMATCH'
+]);
+const FUTURE_FUNCTION_PREFIXES = new Map([
+    [
+        'FILTER',
+        '_xlfn._xlws.'
+    ],
+    [
+        'SORT',
+        '_xlfn._xlws.'
+    ],
+    [
+        'SORTBY',
+        '_xlfn._xlws.'
+    ],
+    [
+        'UNIQUE',
+        '_xlfn.'
+    ],
+    ...Array.from(FUTURE_FUNCTIONS).filter((name)=>![
+            'FILTER',
+            'SORT',
+            'SORTBY',
+            'UNIQUE'
+        ].includes(name)).map((name)=>[
+            name,
+            '_xlfn.'
+        ])
+]);
+function effectiveSpreadsheetCalculationSettings(settings) {
+    if (!settings) return {
+        ...DEFAULT_SPREADSHEET_CALCULATION_SETTINGS
+    };
+    return {
+        mode: settings.mode,
+        fullCalculationOnLoad: Boolean(settings.fullCalculationOnLoad),
+        forceFullCalculation: Boolean(settings.forceFullCalculation),
+        iterativeCalculation: Boolean(settings.iterativeCalculation),
+        maximumIterations: clampedInteger(settings.maximumIterations, 1, 10000, 100),
+        maximumChange: positiveNumber(settings.maximumChange, 0.001),
+        fullPrecision: false !== settings.fullPrecision
+    };
+}
+function editableSpreadsheetFormula(source) {
+    return transformFormulaOutsideStrings(source, (segment)=>segment.replace(/_xlfn\._xlws\.(?=[A-Z][A-Z0-9_.]*\s*\()/gi, '').replace(/_xlfn\.(?=[A-Z][A-Z0-9_.]*\s*\()/gi, '').replace(/_xlws\.(?=[A-Z][A-Z0-9_.]*\s*\()/gi, ''));
+}
+function spreadsheetFormulaForXlsx(currentFormula, sourceFormula) {
+    const current = currentFormula.trim().replace(/^=/, '');
+    const source = sourceFormula?.trim().replace(/^=/, '');
+    if (source && comparableFormula(source) === comparableFormula(current)) return source;
+    return futureFunctionPrefixes(current, source);
+}
+function spreadsheetFormulaRangeForCell(sheet, row, column) {
+    const address = spreadsheetCellAddress(row, column);
+    return (sheet.formulaMetadata?.ranges ?? []).find((range)=>range.anchor.toUpperCase().replaceAll('$', '') === address);
+}
+function spreadsheetFormulaRangesForSelection(sheet, selection) {
+    return (sheet.formulaMetadata?.ranges ?? []).filter((range)=>work_spreadsheet_formulas_rangesOverlap(selection, parseSpreadsheetFormulaRange(range.reference)));
+}
+function spreadsheetFormulaRangeConflict(sheet, range) {
+    const bounds = parseSpreadsheetFormulaRange(range.reference);
+    if (!bounds) return '引用范围无效';
+    const anchor = parseSpreadsheetCellAddress(range.anchor);
+    if (!anchor || !work_spreadsheet_formulas_containsCell(bounds, anchor.row, anchor.column)) return '锚点不在引用范围内';
+    const anchorCell = sheet.data?.[anchor.row]?.[anchor.column];
+    if (!anchorCell) return '锚点单元格不存在';
+    const overlaps = (sheet.formulaMetadata?.ranges ?? []).filter((candidate)=>candidate !== range && work_spreadsheet_formulas_rangesOverlap(bounds, parseSpreadsheetFormulaRange(candidate.reference)));
+    if (overlaps.length) return '与其他公式范围重叠';
+    for (const [row, cells] of (sheet.data ?? []).entries())if (!(row < bounds.startRow) && !(row > bounds.endRow)) {
+        for (const [column, cell] of cells.entries())if (!(column < bounds.startColumn) && !(column > bounds.endColumn)) {
+            if (row !== anchor.row || column !== anchor.column) {
+                if (cell?.f) return `${spreadsheetCellAddress(row, column)} 包含独立公式`;
+            }
+        }
+    }
+    if (Object.values(sheet.config?.merge ?? {}).some((merge)=>work_spreadsheet_formulas_rangesOverlap(bounds, {
+            startRow: merge.r,
+            endRow: merge.r + merge.rs - 1,
+            startColumn: merge.c,
+            endColumn: merge.c + merge.cs - 1
+        }))) return '范围内包含合并单元格';
+    if ('data-table' !== range.type && !anchorCell.f) return '锚点公式已被删除';
+    return null;
+}
+function spreadsheetFormulaFunctions(formula) {
+    const withoutStrings = formula.replace(/"(?:[^"]|"")*"/g, '""');
+    const functions = new Set();
+    for (const match of withoutStrings.matchAll(/(?:_xlfn\.)?(?:_xlws\.)?([A-Z][A-Z0-9_.]*)\s*\(/gi))if (match[1]) functions.add(match[1].toUpperCase());
+    return Array.from(functions);
+}
+function formulaHasExternalReference(formula) {
+    return /\[[^\]]+\][^!]*!/i.test(formula.replace(/"(?:[^"]|"")*"/g, '""'));
+}
+function formulaHasStructuredReference(formula) {
+    const withoutExternalReferences = formula.replace(/"(?:[^"]|"")*"/g, '""').replace(/\[[^\]]+\][^!]*!/gi, '');
+    return /\[(?:@|#)[^\]]+\]/i.test(withoutExternalReferences) || /\b[A-Z_\\][A-Z0-9_.]*\s*\[[^\]]+\]/i.test(withoutExternalReferences);
+}
+function volatileSpreadsheetFormulaFunctions(formula) {
+    return spreadsheetFormulaFunctions(formula).filter((name)=>VOLATILE_FUNCTIONS.has(name));
+}
+function spreadsheetCellAddress(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 parseSpreadsheetFormulaRange(reference) {
+    const normalized = reference.trim().replaceAll('$', '').split('!').at(-1) ?? '';
+    const [startText, endText = startText] = normalized.split(':');
+    const start = parseSpreadsheetCellAddress(startText);
+    const end = parseSpreadsheetCellAddress(endText);
+    if (!start || !end) return null;
+    return {
+        startRow: Math.min(start.row, end.row),
+        endRow: Math.max(start.row, end.row),
+        startColumn: Math.min(start.column, end.column),
+        endColumn: Math.max(start.column, end.column)
+    };
+}
+function parseSpreadsheetCellAddress(address) {
+    const match = /^([A-Z]{1,3})([1-9]\d*)$/i.exec(address.trim().replaceAll('$', ''));
+    if (!match) return null;
+    let column = 0;
+    for (const character of match[1].toUpperCase())column = 26 * column + character.charCodeAt(0) - 64;
+    const row = Number(match[2]) - 1;
+    if (row > 1048575 || column > 16384) return null;
+    return {
+        row,
+        column: column - 1
+    };
+}
+function work_spreadsheet_formulas_containsCell(bounds, row, column) {
+    return row >= bounds.startRow && row <= bounds.endRow && column >= bounds.startColumn && column <= bounds.endColumn;
+}
+function work_spreadsheet_formulas_rangesOverlap(first, second) {
+    if (!second) return false;
+    return first.startRow <= second.endRow && first.endRow >= second.startRow && first.startColumn <= second.endColumn && first.endColumn >= second.startColumn;
+}
+function comparableFormula(formula) {
+    return editableSpreadsheetFormula(formula).trim();
+}
+function futureFunctionPrefixes(formula, sourceFormula) {
+    const sourcePrefixes = new Map();
+    const sourceFunctions = (sourceFormula ?? '').replace(/"(?:[^"]|"")*"/g, '""');
+    for (const match of sourceFunctions.matchAll(/(_xlfn\.(?:_xlws\.)?)([A-Z][A-Z0-9_.]*)\s*(?=\()/gi))if (match[1] && match[2]) sourcePrefixes.set(match[2].toUpperCase(), match[1]);
+    return transformFormulaOutsideStrings(formula, (segment)=>segment.replace(/(?<![A-Z0-9_.])([A-Z][A-Z0-9_.]*)\s*(?=\()/gi, (match, functionName)=>{
+            const normalized = functionName.toUpperCase();
+            const prefix = sourcePrefixes.get(normalized) ?? FUTURE_FUNCTION_PREFIXES.get(normalized);
+            return prefix ? `${prefix}${match}` : match;
+        }));
+}
+function clampedInteger(value, minimum, maximum, fallback) {
+    if (!Number.isFinite(value)) return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.round(value)));
+}
+function positiveNumber(value, fallback) {
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function transformFormulaOutsideStrings(formula, transform) {
+    return formula.split(/("(?:[^"]|"")*")/).map((segment, index)=>index % 2 ? segment : transform(segment)).join('');
+}
+export { OoxmlPackage, attribute, bytesToDataUrl, childPath, contentTypeForPart, createSpreadsheetChartFromSelection, createSpreadsheetPivotFromSelection, defaultPivotValueCaption, defaultWorkSpreadsheetChartSeriesStyle, deleteSpreadsheetPivotTable, descendants, directChild, directChildren, editableSpreadsheetFormula, effectiveSpreadsheetCalculationSettings, errorBarSourceValues, firstDescendant, fitSpreadsheetTrendline, formatSpreadsheetCellRanges, formatSpreadsheetChartAxisNumber, formulaHasExternalReference, formulaHasStructuredReference, isValidSpreadsheetDefinedName, normalizeSpreadsheetPrintArea, normalizeSpreadsheetPrintTitleColumns, normalizeSpreadsheetPrintTitleRows, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetBubbleSizeRepresents, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetChartColor, normalizeWorkSpreadsheetChartGapWidth, normalizeWorkSpreadsheetChartGrouping, normalizeWorkSpreadsheetChartLayout, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartLegendPosition, normalizeWorkSpreadsheetChartOverlap, normalizeWorkSpreadsheetChartSeriesStyle, normalizeWorkSpreadsheetChartSmoothLines, normalizeWorkSpreadsheetCombinationSeriesType, normalizeWorkSpreadsheetDataLabelPosition, normalizeWorkSpreadsheetDataLabels, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetRadarStyle, normalizeWorkSpreadsheetScatterStyle, normalizeWorkSpreadsheetTrendline, normalizeWorkSpreadsheetTrendlineType, parseSpreadsheetCellRanges, parseSpreadsheetChartReference, parseSpreadsheetPrintTitles, parseXml, qualifySpreadsheetRange, readXlsxDrawingAnchor, reconcileSpreadsheetChartPreviews, reconcileSpreadsheetPivots, refreshSpreadsheetPivotTables, resolveSpreadsheetChart, roundChartNumber, spreadsheetCellAddress, spreadsheetChartAxisGridlinesVisible, spreadsheetChartAxisLabelLayout, spreadsheetChartAxisScale, spreadsheetChartAxisValueRatio, spreadsheetChartBarGeometry, spreadsheetChartCategoryLabelVisible, spreadsheetChartCategoryVisualIndex, spreadsheetChartCount, spreadsheetChartSeriesFillStyle, spreadsheetChartSeriesLayout, spreadsheetChartSeriesLegendColor, spreadsheetChartSeriesLineStyle, spreadsheetChartSeriesStyleContext, spreadsheetErrorBarAmounts, spreadsheetFormulaForXlsx, spreadsheetFormulaFunctions, spreadsheetFormulaRangeConflict, spreadsheetFormulaRangeForCell, spreadsheetFormulaRangesForSelection, spreadsheetPivotAggregationLabel, spreadsheetPivotCount, spreadsheetPivotFields, spreadsheetPivotFilterItems, spreadsheetPivotFilterValueKey, spreadsheetPivotIntersects, spreadsheetPivotOutputContains, spreadsheetPivotValidation, spreadsheetSheetsWithChartPreviews, stripSpreadsheetSheetQualifier, volatileSpreadsheetFormulaFunctions, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsCategoryAxis, workSpreadsheetChartAxisIsValueAxis, workSpreadsheetChartAxisLabelPositionLabel, workSpreadsheetChartAxisPositionLabel, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartAxisTickMarkLabel, workSpreadsheetChartGroupingIsStacked, workSpreadsheetChartGroupingLabel, workSpreadsheetChartLegendPositionLabel, workSpreadsheetChartSupportsAxes, workSpreadsheetChartSupportsBarSpacing, workSpreadsheetChartSupportsErrorBars, workSpreadsheetChartSupportsGrouping, workSpreadsheetChartSupportsSeriesAnalysis, workSpreadsheetChartSupportsSmoothLines, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartTypeLabel, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetCombinationSeriesTypeLabel, workSpreadsheetDataLabelPositionLabel, workSpreadsheetErrorBarTypeLabel, workSpreadsheetErrorBarValueTypeLabel, workSpreadsheetTrendlineTypeLabel, xlsxDrawingAnchorToBounds, xlsxTwoCellAnchorMarkers, xmlNamespacePrefix };