@a3s-lab/office 0.35.0 → 0.37.0

package/dist/0~work-office-diagnostics.js

@@ -1950,7 +1950,7 @@ async function diagnoseXlsxFormulas(archive, importedFeatures, worksheetScans) {
     if (dataTables) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.data-tables', `${dataTables} what-if data table(s), input references, and cached results are preserved, but Work does not recalculate scenario tables in the browser.`));
     if (cachedErrors) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.cached-errors', `${cachedErrors} formula cell(s) contain cached Excel error values; the error type and displayed value are preserved in editing, preview, print, and export.`));
     if (externalReferences.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.external-references', `${externalReferences.length} formula cell(s) reference external workbooks; formulas and cached values are preserved without refreshing external files.`));
-    if (structuredReferences.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.structured-references', `${structuredReferences.length} formula cell(s) use structured table references; formulas round-trip unchanged, but the Work calculation engine does not resolve Excel table objects.`));
+    if (structuredReferences.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.structured-references', `${structuredReferences.length} formula cell(s) use structured table references; the browser kernel resolves bounded table names, display names, contiguous column ranges, and common row selectors. Disjoint, external, and advanced forms keep their source formula and cached value for compatible recalculation.`, 'info'));
     if (unsupportedFunctions.size) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.unsupported-functions', `The current browser calculation engine does not evaluate ${Array.from(unsupportedFunctions).sort().join(', ')}; source formulas and cached results are preserved for compatible desktop recalculation.`));
     if (volatileFormulas.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.volatile', `${volatileFormulas.length} volatile formula cell(s) can change when the workbook is explicitly recalculated.`, 'info'));
     if (unsupportedFormulaAttributes.size) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.attributes', `Advanced formula attributes are not represented by the editable model and normalize on export: ${Array.from(unsupportedFormulaAttributes).sort().join(', ')}.`));

package/dist/3266.js

@@ -1,10 +1,512 @@
+import { formulaHasStructuredReference, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, formulaHasExternalReference, spreadsheetFormulaFunctions, editableSpreadsheetFormula, isValidSpreadsheetDefinedName } from "./8715.js";
 import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
 import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
 import { directChild, directChildren, descendants, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, attribute } from "./4121.js";
-import { isValidSpreadsheetDefinedName, sparseArrayEntries } from "./8715.js";
 import { patchWorkOfficeCollaborationFlatJsonMap, readWorkOfficeCollaborationFlatJsonMap } from "./7060.js";
 import { resolveXlsxColor, createXlsxColorResolver, normalizeXlsxSemanticColorOrigin, xlsxPatternFillKey, XLSX_PATTERN_FILL_CELL_KEY, xlsxCellAddress, xlsxSemanticColorMatchesValue, xlsxGradientFillSemanticColors, xlsxColorElementMatchesOrigin, decodeXlsxCellAddress, xlsxSemanticColorOriginSupported, deleteXlsxPatternFill, xlsxCellStyleOrigin, xlsxRgbColor, xlsxPatternFillSemanticColors, activeXlsxGradientFill, xlsxGradientFillKey, applyXlsxSemanticColorOrigin, deleteXlsxGradientFill, XLSX_GRADIENT_FILL_CELL_KEY, readXlsxSemanticColorOrigin, activeXlsxPatternFill } from "./9333.js";
 import * as __rspack_external_yjs from "yjs";
+const MAX_SPREADSHEET_TABLE_CALCULATED_FORMULA_LENGTH = 8192;
+const UNSAFE_SPREADSHEET_TABLE_CALCULATED_FUNCTIONS = new Set([
+    'CALL',
+    'DDE',
+    'DDE.REQUEST',
+    'DDE.POKE',
+    'EXEC',
+    'HYPERLINK',
+    'INDIRECT',
+    'OFFSET',
+    'REGISTER.ID',
+    'RTD',
+    'WEBSERVICE'
+]);
+function normalizeSpreadsheetTableCalculatedFormula(value) {
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    const formula = trimmed.startsWith('=') ? trimmed : `=${trimmed}`;
+    if (formula.startsWith('==') || formula.length > MAX_SPREADSHEET_TABLE_CALCULATED_FORMULA_LENGTH || /[\u0000-\u001f\u007f]/u.test(formula) || formulaHasExternalReference(formula) || !formulaHasStructuredReference(formula) || spreadsheetFormulaFunctions(formula).some((name)=>UNSAFE_SPREADSHEET_TABLE_CALCULATED_FUNCTIONS.has(name))) return;
+    const editable = editableSpreadsheetFormula(formula).trim();
+    return editable || void 0;
+}
+function reconcileSpreadsheetTableCalculatedColumns(sheet, table) {
+    return table.columns.map((column, offset)=>{
+        const declared = normalizeSpreadsheetTableCalculatedFormula(column.calculatedFormula);
+        const observed = spreadsheetTableCurrentRowFormulas(sheet, table, offset);
+        const uniqueObserved = new Set(observed);
+        if (uniqueObserved.size > 1) return stripCalculatedFormula(column);
+        const inferred = uniqueObserved.values().next().value;
+        if (declared && inferred && declared !== inferred) return stripCalculatedFormula(column);
+        if (declared) return {
+            ...column,
+            calculatedFormula: declared
+        };
+        return inferred ? {
+            ...column,
+            calculatedFormula: inferred
+        } : stripCalculatedFormula(column);
+    });
+}
+function isSpreadsheetTableCalculatedFormula(value) {
+    const formula = normalizeSpreadsheetTableCalculatedFormula(value);
+    return Boolean(formula && hasCurrentRowReference(formula));
+}
+function fillSpreadsheetTableCalculatedColumns(sheet, table, rows) {
+    const targetRows = Array.from(new Set(rows.filter((row)=>Number.isSafeInteger(row) && row >= table.range.row[0] + Number(table.headerRow) && row <= table.range.row[1] - Number(table.totalsRow)))).sort((left, right)=>left - right);
+    if (!targetRows.length) return sheet;
+    const formulas = table.columns.map((column)=>isSpreadsheetTableCalculatedFormula(column.calculatedFormula) ? normalizeSpreadsheetTableCalculatedFormula(column.calculatedFormula) : void 0);
+    if (!formulas.some(Boolean)) return sheet;
+    if (void 0 !== sheet.data) {
+        const data = sheet.data.slice();
+        const mutableRows = new Map();
+        let changed = false;
+        for (const rowIndex of targetRows){
+            const sourceRow = data[rowIndex];
+            let row = mutableRows.get(rowIndex);
+            for(let offset = 0; offset < formulas.length; offset += 1){
+                const formula = formulas[offset];
+                if (!formula) continue;
+                const column = table.range.column[0] + offset;
+                const current = sourceRow?.[column] ?? null;
+                if (!spreadsheetTableCellIsEmpty(current)) continue;
+                row ??= cloneSpreadsheetTableRow(sourceRow);
+                mutableRows.set(rowIndex, row);
+                const styleSource = current ?? nearestSpreadsheetTableCell(sheet, table, rowIndex, column);
+                row[column] = spreadsheetCellWithCalculatedFormula(styleSource, formula);
+                changed = true;
+            }
+            if (row) data[rowIndex] = row;
+        }
+        return changed ? {
+            ...sheet,
+            data
+        } : sheet;
+    }
+    const entries = [
+        ...sheet.celldata ?? []
+    ];
+    const byCoordinate = new Map(entries.map((entry, index)=>[
+            `${entry.r}:${entry.c}`,
+            index
+        ]));
+    let changed = false;
+    for (const row of targetRows)for(let offset = 0; offset < formulas.length; offset += 1){
+        const formula = formulas[offset];
+        if (!formula) continue;
+        const column = table.range.column[0] + offset;
+        const key = `${row}:${column}`;
+        const index = byCoordinate.get(key);
+        const current = void 0 === index ? null : entries[index]?.v;
+        if (!spreadsheetTableCellIsEmpty(current)) continue;
+        const styleSource = current ?? nearestSpreadsheetTableCell(sheet, table, row, column);
+        const entry = {
+            r: row,
+            c: column,
+            v: spreadsheetCellWithCalculatedFormula(styleSource, formula)
+        };
+        if (void 0 === index) {
+            byCoordinate.set(key, entries.length);
+            entries.push(entry);
+        } else entries[index] = entry;
+        changed = true;
+    }
+    if (!changed) return sheet;
+    entries.sort((left, right)=>left.r - right.r || left.c - right.c);
+    return {
+        ...sheet,
+        celldata: entries
+    };
+}
+function spreadsheetTableCellAt(sheet, row, column) {
+    return sheet.data?.[row]?.[column] ?? sheet.celldata?.find((entry)=>entry.r === row && entry.c === column)?.v ?? null;
+}
+function spreadsheetTableCellIsEmpty(cell) {
+    return !cell?.f && (cell?.v === void 0 || null === cell.v || '' === cell.v) && (cell?.m === void 0 || null === cell.m || '' === cell.m);
+}
+function spreadsheetCellWithCalculatedFormula(source, formula) {
+    const { f: _formula, m: _display, v: _value, ...presentation } = source ?? {};
+    return {
+        ...presentation,
+        f: formula
+    };
+}
+function stripCalculatedFormula(column) {
+    if (void 0 === column.calculatedFormula) return column;
+    const { calculatedFormula: _formula, ...withoutFormula } = column;
+    return withoutFormula;
+}
+function hasCurrentRowReference(formula) {
+    const source = formula.replace(/"(?:[^"]|"")*"/g, '""');
+    return /\[@/i.test(source) || /\[#This Row\]/i.test(source);
+}
+function spreadsheetTableCurrentRowFormulas(sheet, table, columnOffset) {
+    const startRow = table.range.row[0] + Number(table.headerRow);
+    const endRow = table.range.row[1] - Number(table.totalsRow);
+    const column = table.range.column[0] + columnOffset;
+    const formulas = [];
+    for(let row = startRow; row <= endRow; row += 1){
+        const formula = normalizeSpreadsheetTableCalculatedFormula(spreadsheetTableCellAt(sheet, row, column)?.f);
+        if (formula && hasCurrentRowReference(formula)) formulas.push(formula);
+    }
+    return formulas;
+}
+function cloneSpreadsheetTableRow(source) {
+    const row = [];
+    if (!source) return row;
+    row.length = source.length;
+    for (const column of spreadsheet_sparse_sparseArrayEntries(source).map(([index])=>index))row[column] = source[column];
+    return row;
+}
+function nearestSpreadsheetTableCell(sheet, table, row, column) {
+    const start = table.range.row[0] + Number(table.headerRow);
+    const end = table.range.row[1] - Number(table.totalsRow);
+    for(let distance = 1; distance <= end - start; distance += 1){
+        const before = row - distance;
+        if (before >= start) {
+            const cell = spreadsheetTableCellAt(sheet, before, column);
+            if (cell) return cell;
+        }
+        const after = row + distance;
+        if (after <= end) {
+            const cell = spreadsheetTableCellAt(sheet, after, column);
+            if (cell) return cell;
+        }
+    }
+    return null;
+}
+const MAX_SPREADSHEET_TABLE_TOTALS_FORMULA_LENGTH = 8192;
+const MAX_SPREADSHEET_TABLE_TOTALS_LABEL_LENGTH = 255;
+const DEFAULT_SPREADSHEET_TABLE_TOTALS_LABEL = 'Total';
+const SPREADSHEET_TABLE_TOTALS_FUNCTIONS = Object.freeze([
+    'sum',
+    'average',
+    'count',
+    'countNums',
+    'max',
+    'min',
+    'stdDev',
+    'stdDevP',
+    'var',
+    'varP',
+    'custom'
+]);
+const UNSAFE_TOTALS_FUNCTIONS = new Set([
+    'CALL',
+    'DDE',
+    'DDE.REQUEST',
+    'DDE.POKE',
+    'EXEC',
+    'HYPERLINK',
+    'INDIRECT',
+    'OFFSET',
+    'REGISTER.ID',
+    'RTD',
+    'WEBSERVICE'
+]);
+const SUBTOTAL_CODES = {
+    average: 101,
+    count: 103,
+    countNums: 102,
+    max: 104,
+    min: 105,
+    stdDev: 107,
+    stdDevP: 108,
+    sum: 109,
+    var: 110,
+    varP: 111
+};
+const OOXML_TOTALS_FUNCTIONS = {
+    average: 'average',
+    count: 'count',
+    countNums: 'countNums',
+    max: 'max',
+    min: 'min',
+    stdDev: 'stdDev',
+    stdDevP: 'stdDevp',
+    sum: 'sum',
+    var: 'var',
+    varP: 'varp'
+};
+const TOTALS_FUNCTION_LABELS = {
+    sum: '求和',
+    average: '平均值',
+    count: '计数',
+    countNums: '数值计数',
+    max: '最大值',
+    min: '最小值',
+    stdDev: '标准差',
+    stdDevP: '总体标准差',
+    var: '方差',
+    varP: '总体方差',
+    custom: '自定义'
+};
+function spreadsheetTableTotalsFunctionLabel(value) {
+    return value ? TOTALS_FUNCTION_LABELS[value] : '不汇总';
+}
+function normalizeSpreadsheetTableTotalsFunction(value) {
+    if ('string' != typeof value) return;
+    if ('none' === value || '' === value) return;
+    return SPREADSHEET_TABLE_TOTALS_FUNCTIONS.includes(value) ? value : void 0;
+}
+function normalizeSpreadsheetTableTotalsFormula(value) {
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    const formula = trimmed.startsWith('=') ? trimmed : `=${trimmed}`;
+    if (formula.startsWith('==') || formula.length > MAX_SPREADSHEET_TABLE_TOTALS_FORMULA_LENGTH || /[\u0000-\u001f\u007f]/u.test(formula) || formulaHasExternalReference(formula) || spreadsheetFormulaFunctions(formula).some((name)=>UNSAFE_TOTALS_FUNCTIONS.has(name))) return;
+    const editable = editableSpreadsheetFormula(formula).trim();
+    return editable || void 0;
+}
+function normalizeSpreadsheetTableTotalsLabel(value) {
+    if ('string' != typeof value) return;
+    const label = value.trim();
+    if (!label || Array.from(label).length > MAX_SPREADSHEET_TABLE_TOTALS_LABEL_LENGTH || /[\u0000-\u001f\u007f]/u.test(label)) return;
+    return label;
+}
+function spreadsheetTableTotalsFunctionFromOoxml(value) {
+    if ('string' != typeof value) return;
+    const normalized = value.trim().toLowerCase();
+    if ('custom' === normalized) return 'custom';
+    const entry = Object.entries(OOXML_TOTALS_FUNCTIONS).find(([, token])=>token.toLowerCase() === normalized);
+    return entry?.[0];
+}
+function spreadsheetTableTotalsFunctionToOoxml(value) {
+    if (!value || 'custom' === value) return 'custom' === value ? 'custom' : void 0;
+    return OOXML_TOTALS_FUNCTIONS[value];
+}
+function spreadsheetTableTotalsFormula(table, columnOffset) {
+    const column = table.columns[columnOffset];
+    if (!column) return;
+    const custom = normalizeSpreadsheetTableTotalsFormula(column.totalsFormula);
+    if (custom) return custom;
+    const functionName = normalizeSpreadsheetTableTotalsFunction(column.totalsFunction);
+    if (!functionName || 'custom' === functionName) return;
+    const code = SUBTOTAL_CODES[functionName];
+    if (!code) return;
+    return `=SUBTOTAL(${code},${table.name}[${escapeStructuredColumnName(column.name)}])`;
+}
+function spreadsheetTableTotalsColumnPatch(columns, patches) {
+    if (void 0 === patches) return columns.map((column)=>({
+            ...column
+        }));
+    const entries = Array.isArray(patches) ? patches.flatMap((patch, offset)=>patch ? [
+            [
+                String(offset),
+                patch
+            ]
+        ] : []) : Object.entries(patches);
+    const next = columns.map((column)=>({
+            ...column
+        }));
+    for (const [rawOffset, patch] of entries){
+        const offset = Number(rawOffset);
+        if (!Number.isSafeInteger(offset) || offset < 0 || offset >= next.length || !patch || 'object' != typeof patch || Array.isArray(patch)) return null;
+        const current = next[offset];
+        if (!current) return null;
+        const candidate = {
+            ...current
+        };
+        if (Object.hasOwn(patch, 'totalsFunction')) if (null === patch.totalsFunction || '' === patch.totalsFunction) delete candidate.totalsFunction;
+        else {
+            const functionName = normalizeSpreadsheetTableTotalsFunction(patch.totalsFunction);
+            if (!functionName) return null;
+            candidate.totalsFunction = functionName;
+        }
+        if (Object.hasOwn(patch, 'totalsLabel')) if (null === patch.totalsLabel || '' === patch.totalsLabel) delete candidate.totalsLabel;
+        else {
+            const label = normalizeSpreadsheetTableTotalsLabel(patch.totalsLabel);
+            if (!label) return null;
+            candidate.totalsLabel = label;
+        }
+        if (Object.hasOwn(patch, 'totalsFormula')) if (null === patch.totalsFormula || '' === patch.totalsFormula) delete candidate.totalsFormula;
+        else {
+            const formula = normalizeSpreadsheetTableTotalsFormula(patch.totalsFormula);
+            if (!formula) return null;
+            candidate.totalsFormula = formula;
+        }
+        if (candidate.totalsFormula) {
+            if (void 0 !== candidate.totalsFunction && 'custom' !== candidate.totalsFunction) return null;
+            candidate.totalsFunction = 'custom';
+        } else if ('custom' === candidate.totalsFunction) return null;
+        if (void 0 !== candidate.totalsFunction && 'custom' !== candidate.totalsFunction) delete candidate.totalsFormula;
+        if (void 0 !== candidate.totalsFunction && candidate.totalsLabel) delete candidate.totalsLabel;
+        next[offset] = candidate;
+    }
+    return next;
+}
+function withDefaultSpreadsheetTableTotalsLabel(columns, totalsRow) {
+    const next = columns.map((column)=>({
+            ...column
+        }));
+    if (!totalsRow || !next.length) return next;
+    const hasExplicitLabel = next.some((column)=>column.totalsLabel);
+    if (hasExplicitLabel) return next;
+    const first = next[0];
+    if (first && !first.totalsFunction && !first.totalsFormula) first.totalsLabel = DEFAULT_SPREADSHEET_TABLE_TOTALS_LABEL;
+    return next;
+}
+function spreadsheetTableTotalsRowHasContent(sheet, table, row = table.totalsRow ? table.range.row[1] : table.range.row[1] + 1) {
+    for(let column = table.range.column[0]; column <= table.range.column[1]; column += 1)if (!spreadsheetTableTotalsCellIsEmpty(spreadsheetTableTotalsCellAt(sheet, row, column))) return true;
+    return false;
+}
+function synchronizeSpreadsheetTableTotalsRow(sheet, previousTable, nextTable, options = {}) {
+    if (!nextTable.totalsRow) return sheet;
+    const force = true === options.force;
+    const previousRow = previousTable?.range.row[1];
+    const nextRow = nextTable.range.row[1];
+    const width = nextTable.range.column[1] - nextTable.range.column[0] + 1;
+    const updates = new Map();
+    for(let offset = 0; offset < width; offset += 1){
+        const column = nextTable.range.column[0] + offset;
+        const nextColumn = nextTable.columns[offset];
+        if (!nextColumn) continue;
+        const previousColumn = previousTable?.columns[offset];
+        const oldFormula = previousTable ? spreadsheetTableTotalsFormula(previousTable, offset) : void 0;
+        const newFormula = spreadsheetTableTotalsFormula(nextTable, offset);
+        const oldLabel = normalizeSpreadsheetTableTotalsLabel(previousColumn?.totalsLabel);
+        const newLabel = normalizeSpreadsheetTableTotalsLabel(nextColumn.totalsLabel);
+        const changed = force || void 0 === previousTable || previousTable.name !== nextTable.name || previousTable.range.row[1] !== nextTable.range.row[1] || previousColumn?.totalsFunction !== nextColumn.totalsFunction || previousColumn?.totalsFormula !== nextColumn.totalsFormula || previousColumn?.totalsLabel !== nextColumn.totalsLabel || previousColumn?.name !== nextColumn.name;
+        const current = spreadsheetTableTotalsCellAt(sheet, nextRow, column);
+        const previousCell = void 0 === previousRow ? null : spreadsheetTableTotalsCellAt(sheet, previousRow, column);
+        const styleSource = current ?? previousCell;
+        const empty = spreadsheetTableTotalsCellIsEmpty(current);
+        const currentFormula = normalizeSpreadsheetTableTotalsFormula(current?.f);
+        const generatedFormula = Boolean(oldFormula && currentFormula && formulasEqual(currentFormula, oldFormula));
+        const generatedLabel = Boolean(oldLabel && !current?.f && spreadsheetTableCellText(current) === oldLabel);
+        const replaceable = force || empty || changed && (generatedFormula || generatedLabel);
+        if (newFormula && replaceable) updates.set(column, spreadsheetCellWithTotalsFormula(styleSource, newFormula));
+        else if (newLabel && replaceable) updates.set(column, spreadsheetCellWithTotalsLabel(styleSource, newLabel));
+        else if (!newFormula && !newLabel && changed && (generatedFormula || generatedLabel)) updates.set(column, clearSpreadsheetTableTotalsCell(current));
+    }
+    return applySpreadsheetTableTotalsCellUpdates(sheet, nextRow, updates);
+}
+function reconcileSpreadsheetTableTotalsColumns(sheet, table, editedOffsets) {
+    return table.columns.map((column, offset)=>{
+        const candidate = {
+            ...column
+        };
+        const declaredFunction = normalizeSpreadsheetTableTotalsFunction(candidate.totalsFunction);
+        const declaredFormula = normalizeSpreadsheetTableTotalsFormula(candidate.totalsFormula);
+        if (declaredFunction) candidate.totalsFunction = declaredFunction;
+        else delete candidate.totalsFunction;
+        if (declaredFormula) candidate.totalsFormula = declaredFormula;
+        else delete candidate.totalsFormula;
+        const label = normalizeSpreadsheetTableTotalsLabel(candidate.totalsLabel);
+        if (label) candidate.totalsLabel = label;
+        else delete candidate.totalsLabel;
+        if (!table.totalsRow) return candidate;
+        const cell = spreadsheetTableTotalsCellAt(sheet, table.range.row[1], table.range.column[0] + offset);
+        if (editedOffsets && !editedOffsets.has(offset)) return candidate;
+        const cellFormula = normalizeSpreadsheetTableTotalsFormula(cell?.f);
+        const expected = spreadsheetTableTotalsFormula({
+            ...table,
+            columns: [
+                {
+                    ...candidate
+                }
+            ]
+        }, 0);
+        if (cellFormula) {
+            if (expected && formulasEqual(cellFormula, expected)) return candidate;
+            delete candidate.totalsFunction;
+            delete candidate.totalsFormula;
+            candidate.totalsFunction = 'custom';
+            candidate.totalsFormula = cellFormula;
+            return candidate;
+        }
+        delete candidate.totalsFunction;
+        delete candidate.totalsFormula;
+        const cellLabel = normalizeSpreadsheetTableTotalsLabel(spreadsheetTableCellText(cell));
+        if (cellLabel) if (candidate.totalsLabel && candidate.totalsLabel !== cellLabel) delete candidate.totalsLabel;
+        else candidate.totalsLabel = cellLabel;
+        else delete candidate.totalsLabel;
+        return candidate;
+    });
+}
+function escapeStructuredColumnName(value) {
+    return value.replaceAll(']', ']]');
+}
+function formulasEqual(left, right) {
+    return left.trim().replace(/\s+/g, '').toLocaleLowerCase() === right.trim().replace(/\s+/g, '').toLocaleLowerCase();
+}
+function spreadsheetTableTotalsCellAt(sheet, row, column) {
+    return sheet.data?.[row]?.[column] ?? sheet.celldata?.find((entry)=>entry.r === row && entry.c === column)?.v ?? null;
+}
+function spreadsheetTableTotalsCellIsEmpty(cell) {
+    return !cell?.f && (cell?.v === void 0 || null === cell.v || '' === cell.v) && (cell?.m === void 0 || null === cell.m || '' === cell.m);
+}
+function spreadsheetTableCellText(cell) {
+    const value = cell?.m ?? cell?.v;
+    return null == value ? '' : String(value);
+}
+function spreadsheetCellWithTotalsFormula(source, formula) {
+    const { f: _formula, m: _display, v: _value, ...presentation } = source ?? {};
+    return {
+        ...presentation,
+        f: formula
+    };
+}
+function spreadsheetCellWithTotalsLabel(source, label) {
+    const { f: _formula, ...withoutFormula } = source ?? {};
+    return {
+        ...withoutFormula,
+        m: label,
+        v: label
+    };
+}
+function clearSpreadsheetTableTotalsCell(source) {
+    if (!source) return null;
+    const { f: _formula, m: _display, v: _value, ...presentation } = source;
+    return Object.keys(presentation).length ? presentation : null;
+}
+function applySpreadsheetTableTotalsCellUpdates(sheet, rowIndex, updates) {
+    if (!updates.size) return sheet;
+    if (void 0 !== sheet.data) {
+        const data = sheet.data.slice();
+        const source = data[rowIndex];
+        const row = source ? source.slice() : [];
+        for (const [column, cell] of updates)row[column] = cell;
+        data[rowIndex] = row;
+        return {
+            ...sheet,
+            data
+        };
+    }
+    const entries = [
+        ...sheet.celldata ?? []
+    ];
+    const indexes = new Map(entries.map((entry, index)=>[
+            `${entry.r}:${entry.c}`,
+            index
+        ]));
+    for (const [column, cell] of updates){
+        const key = `${rowIndex}:${column}`;
+        const index = indexes.get(key);
+        if (null === cell) {
+            if (void 0 !== index) entries.splice(index, 1);
+            if (void 0 !== index) {
+                indexes.clear();
+                entries.forEach((entry, nextIndex)=>{
+                    indexes.set(`${entry.r}:${entry.c}`, nextIndex);
+                });
+            }
+            continue;
+        }
+        const entry = {
+            r: rowIndex,
+            c: column,
+            v: cell
+        };
+        if (void 0 === index) {
+            indexes.set(key, entries.length);
+            entries.push(entry);
+        } else entries[index] = entry;
+    }
+    entries.sort((left, right)=>left.r - right.r || left.c - right.c);
+    return {
+        ...sheet,
+        celldata: entries
+    };
+}
 function requiredCoordinate(value, maximum, label, sheetId) {
     if (!Number.isSafeInteger(value) || value < 0 || value >= maximum) invalidWorkOfficeSpreadsheetInput(`a valid ${label} coordinate in sheet '${sheetId}'`);
     return value;
@@ -258,18 +760,55 @@ function requiredSpreadsheetTableColumns(value, width, label) {
     const names = new Set();
     return value.map((candidate)=>{
         const record = requiredInputRecord(candidate, `${label} column`);
-        assertExactRecordKeys(record, [
-            'name'
+        assertOptionalRecordKeys(record, [
+            'name',
+            'calculatedFormula',
+            'totalsFunction',
+            'totalsLabel',
+            'totalsFormula'
         ], `column for ${label}`);
         const name = requiredTableColumnName(record.name, label);
         const normalized = name.toLocaleLowerCase();
         if (names.has(normalized)) invalidWorkOfficeSpreadsheetInput(`unique column names for ${label}`);
         names.add(normalized);
-        return {
+        let calculatedFormula;
+        if (void 0 !== record.calculatedFormula) {
+            calculatedFormula = normalizeSpreadsheetTableCalculatedFormula(record.calculatedFormula);
+            if (!calculatedFormula || calculatedFormula !== record.calculatedFormula) invalidWorkOfficeSpreadsheetInput(`a bounded structured calculated-column formula for ${label}`);
+        }
+        const totalsFunction = void 0 === record.totalsFunction ? void 0 : normalizeSpreadsheetTableTotalsFunction(record.totalsFunction);
+        if (void 0 !== record.totalsFunction && (!totalsFunction || totalsFunction !== record.totalsFunction)) invalidWorkOfficeSpreadsheetInput(`a supported totals-row function for ${label}`);
+        const totalsLabel = void 0 === record.totalsLabel ? void 0 : normalizeSpreadsheetTableTotalsLabel(record.totalsLabel);
+        if (void 0 !== record.totalsLabel && (!totalsLabel || totalsLabel !== record.totalsLabel)) invalidWorkOfficeSpreadsheetInput(`a bounded totals-row label for ${label}`);
+        const totalsFormula = void 0 === record.totalsFormula ? void 0 : normalizeSpreadsheetTableTotalsFormula(record.totalsFormula);
+        if (void 0 !== record.totalsFormula && (!totalsFormula || totalsFormula !== record.totalsFormula)) invalidWorkOfficeSpreadsheetInput(`a bounded totals-row formula for ${label}`);
+        if (totalsFormula && 'custom' !== totalsFunction) invalidWorkOfficeSpreadsheetInput(`custom totals-row formulas to declare the custom function for ${label}`);
+        if ('custom' === totalsFunction && !totalsFormula) invalidWorkOfficeSpreadsheetInput(`custom totals-row functions to include a formula for ${label}`);
+        if ((totalsFunction || totalsFormula) && totalsLabel) invalidWorkOfficeSpreadsheetInput(`totals-row labels not to share a cell with a formula for ${label}`);
+        if (!calculatedFormula && !totalsFunction && !totalsLabel && !totalsFormula) return {
             name
         };
+        return {
+            name,
+            ...calculatedFormula ? {
+                calculatedFormula
+            } : {},
+            ...totalsFunction ? {
+                totalsFunction
+            } : {},
+            ...totalsLabel ? {
+                totalsLabel
+            } : {},
+            ...totalsFormula ? {
+                totalsFormula
+            } : {}
+        };
     });
 }
+function assertOptionalRecordKeys(record, keys, label) {
+    const allowed = new Set(keys);
+    if (!Object.hasOwn(record, keys[0] ?? '') || Object.keys(record).some((key)=>!allowed.has(key))) invalidWorkOfficeSpreadsheetInput(`a complete ${label} record without unknown fields`);
+}
 function requiredSpreadsheetTableFilters(value, width, label) {
     if (!Array.isArray(value)) invalidWorkOfficeSpreadsheetInput(`an array of filters for ${label}`);
     const columns = new Set();
@@ -744,7 +1283,7 @@ function assertCompatibleValue(previous, next, shared, label) {
 function spreadsheetCells(sheet) {
     const result = new Map();
     if (void 0 !== sheet.data) {
-        for (const [row, values] of sparseArrayEntries(sheet.data))for (const [column, cell] of sparseArrayEntries(values))if (null !== cell) result.set(`${row}:${column}`, cell);
+        for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values))if (null !== cell) result.set(`${row}:${column}`, cell);
         return result;
     }
     for (const entry of sheet.celldata ?? [])if (null !== entry.v) result.set(`${entry.r}:${entry.c}`, entry.v);
@@ -854,7 +1393,7 @@ function spreadsheetCellEntries(sheet) {
     if (!sheet) return [];
     const entries = [];
     if (void 0 !== sheet.data) {
-        for (const [row, values] of sparseArrayEntries(sheet.data))for (const [column, cell] of sparseArrayEntries(values))if (null !== cell) entries.push({
+        for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values))if (null !== cell) entries.push({
             cell,
             column,
             coordinate: encodedCoordinate(row, column),
@@ -2216,12 +2755,12 @@ function xlsxRichTextCellText(cell) {
     return normalizeXlsxRichTextCell(cell)?.text ?? null;
 }
 function sheetHasXlsxRichTextCells(sheet) {
-    for (const [, row] of sparseArrayEntries(sheet.data))for (const [, cell] of sparseArrayEntries(row))if (cell && normalizeXlsxRichTextCell(cell)) return true;
+    for (const [, row] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [, cell] of spreadsheet_sparse_sparseArrayEntries(row))if (cell && normalizeXlsxRichTextCell(cell)) return true;
     return false;
 }
 function xlsxRichTextStyleOrigins(sheet) {
     const origins = [];
-    for (const [, row] of sparseArrayEntries(sheet.data))for (const [, cell] of sparseArrayEntries(row))if (cell) for (const run of normalizeXlsxRichTextCell(cell)?.runs ?? []){
+    for (const [, row] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [, cell] of spreadsheet_sparse_sparseArrayEntries(row))if (cell) for (const run of normalizeXlsxRichTextCell(cell)?.runs ?? []){
         const fontColor = normalizeXlsxSemanticColorOrigin(run.a3sXlsxColorOrigin);
         if (fontColor && run.fc && xlsxSemanticColorMatchesValue(fontColor, run.fc)) origins.push({
             fontColor
@@ -2241,7 +2780,7 @@ function writeXlsxRichTextCells(worksheet, sheet, semanticPalette) {
     }));
     let remainingCells = 10000;
     let remainingRuns = 100000;
-    for (const [row, values] of sparseArrayEntries(sheet.data))for (const [column, cell] of sparseArrayEntries(values)){
+    for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values)){
         if (remainingCells <= 0 || remainingRuns <= 0) return;
         if (!cell) continue;
         const richText = normalizeXlsxRichTextCell(cell);
@@ -2384,4 +2923,4 @@ function work_xlsx_rich_text_nonNegativeInteger(value) {
 function work_xlsx_rich_text_isRecord(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
 }
-export { activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, coalesceXlsxRichTextRuns, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isHighSurrogate, isLowSurrogate, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeXlsxRichTextCell, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextRun, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sameXlsxRichTextRunStyle, sheetHasXlsxRichTextCells, spreadsheetCellValueWithDiagonalBorder, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, validXlsxRichText, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };
+export { SPREADSHEET_TABLE_TOTALS_FUNCTIONS, activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, coalesceXlsxRichTextRuns, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, fillSpreadsheetTableCalculatedColumns, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isHighSurrogate, isLowSurrogate, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetTableCalculatedFormula, normalizeSpreadsheetTableTotalsFormula, normalizeSpreadsheetTableTotalsLabel, normalizeXlsxRichTextCell, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextRun, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, reconcileSpreadsheetTableCalculatedColumns, reconcileSpreadsheetTableTotalsColumns, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sameXlsxRichTextRunStyle, sheetHasXlsxRichTextCells, spreadsheetCellValueWithDiagonalBorder, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetTableTotalsColumnPatch, spreadsheetTableTotalsFunctionFromOoxml, spreadsheetTableTotalsFunctionLabel, spreadsheetTableTotalsFunctionToOoxml, spreadsheetTableTotalsRowHasContent, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, synchronizeSpreadsheetTableTotalsRow, validXlsxRichText, withDefaultSpreadsheetTableTotalsLabel, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };