@a3s-lab/office 0.35.0 → 0.36.0

package/dist/0~spreadsheet-editor.js

@@ -6,7 +6,7 @@ import { Fragment as external_react_Fragment, cloneElement, memo, useCallback, u
 import { convertSpanToShareString, genarate, indexToColumnChar, update as core_update } from "@fortune-sheet/core";
 import { freezeImportedSpreadsheetCell, normalizeXlsxSemanticColorOrigin, spreadsheetMatrixProfile, withXlsxPatternFill, withoutEditableRange, normalizeSpreadsheetConditionalVisualOptions, xlsxSemanticColorMatchesValue, withXlsxGradientFill, effectiveSpreadsheetPageSetup, attachSpreadsheetShownCommentCells, normalizeXlsxPatternFill, withEditableRange, sameSpreadsheetHistoryValue, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconForValue, defaultSpreadsheetConditionalIconThresholds, xlsxPatternFillTypes, sheetProtectionAuthority, normalizeXlsxGradientFill, xlsxGradientFillFallbackColor, editableRangeCellCount, unlockedCellCount, registerDerivedSpreadsheetMatrix, editableRangeRequiresCredentials, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, normalizeSpreadsheetConditionalIconSetFormat, defaultSpreadsheetDataBarOptions, spreadsheetConditionalThresholdValue, normalizeSheetProtectionAuthority, withSheetProtection, spreadsheetProtectionKey, defaultSpreadsheetColorScaleThresholds, protectedSheetCount, SPREADSHEET_CONDITIONAL_ICON_SETS, withSheetSelectionPermissions, spreadsheetConditionalComparisonNeedsUpperValue, drawSpreadsheetConditionalIcon, spreadsheetConditionalThresholdsEqual } from "./9333.js";
 import { workSpreadsheetChartSupportsGrouping, spreadsheetFormulaRangesForSelection, createSpreadsheetChartFromSelection, normalizeWorkSpreadsheetDataLabelPosition, normalizeSpreadsheetPrintTitleColumns, normalizeSpreadsheetPrintTitleRows, formulaHasStructuredReference, normalizeWorkSpreadsheetErrorBars, defaultPivotValueCaption, workSpreadsheetChartSupportsBarSpacing, normalizeWorkSpreadsheetChartGrouping, spreadsheetGridSize, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetScatterStyle, cloneSparseMatrix, spreadsheetPivotAggregationLabel, workSpreadsheetChartAxisIsCategoryAxis, reconcileSpreadsheetChartPreviews, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetChartLegendPosition, spreadsheetChartCount, workSpreadsheetChartTypeLabel, sparseArrayEntries, normalizeWorkSpreadsheetTrendline, effectiveSpreadsheetCalculationSettings, spreadsheetPivotIntersects, normalizeWorkSpreadsheetDataLabels, spreadsheetPivotOutputContains, normalizeSpreadsheetPrintArea, spreadsheetCellAddress, formatSpreadsheetCellRanges, normalizeWorkSpreadsheetChartLayout, spreadsheetFormulaRangeForCell, workSpreadsheetChartAxisIsValueAxis, normalizeWorkSpreadsheetChartSmoothLines, spreadsheetPivotFilterValueKey, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetChartSeriesStyle, volatileSpreadsheetFormulaFunctions, sparseArrayIndexes, normalizeWorkSpreadsheetBubbleSizeRepresents, workSpreadsheetChartSupportsTrendlines, normalizeWorkSpreadsheetChartLegendOverlay, parseSpreadsheetChartReference, workSpreadsheetChartGroupingIsStacked, normalizeWorkSpreadsheetChartGapWidth, workSpreadsheetChartSupportsSmoothLines, refreshSpreadsheetPivotTables, createSpreadsheetPivotFromSelection, reconcileSpreadsheetPivots, spreadsheetPivotCount, sparseMatrixColumnCount, workSpreadsheetChartSupportsErrorBars, formulaHasExternalReference, isValidSpreadsheetDefinedName, spreadsheetPivotValidation, deleteSpreadsheetPivotTable, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartSupportsSeriesAnalysis, parseSpreadsheetCellRanges, spreadsheetPivotFilterItems, spreadsheetPivotFields, normalizeWorkSpreadsheetChartOverlap, spreadsheetFormulaRangeConflict, spreadsheetSheetsWithChartPreviews, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartSupportsAxes, normalizeWorkSpreadsheetCombinationSeriesType, normalizeWorkSpreadsheetRadarStyle } from "./8715.js";
-import { spreadsheetTextOrientationFromChoice, isSpreadsheetTextOrientationId, xlsxRichTextCellText, spreadsheetTextOrientationFromAngle, spreadsheetCellValueWithDiagonalBorder, spreadsheetUnderlineCellValue, normalizeSpreadsheetDataValidationErrorStyle, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextColor, isHighSurrogate, xlsxNativeFillCellKeys, createOfficeSpreadsheetCollaborationBinding as createWorkOfficeSpreadsheetCollaborationBinding, boundedSpreadsheetDataValidationText, normalizeSpreadsheetDateValidationBoundary, normalizeXlsxRichTextCell, activeXlsxNativeFill, spreadsheetUnderlineStyle, deleteXlsxNativeFills, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, normalizeXlsxRichTextRun, spreadsheetDiagonalBorderFromCellValue, sameXlsxRichTextRunStyle, isLowSurrogate, spreadsheetTextOrientationFromCell, coalesceXlsxRichTextRuns, patchSpreadsheetRichTextFontRuns, replaceOfficeSpreadsheetCollaboration as replaceWorkOfficeSpreadsheetCollaboration, validXlsxRichText, readOfficeSpreadsheetCollaboration as readWorkOfficeSpreadsheetCollaboration, isSpreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell } from "./3266.js";
+import { reconcileSpreadsheetTableCalculatedColumns, spreadsheetTextOrientationFromChoice, xlsxRichTextCellText, isSpreadsheetTextOrientationId, spreadsheetTextOrientationFromAngle, readOfficeSpreadsheetCollaboration as readWorkOfficeSpreadsheetCollaboration, spreadsheetCellValueWithDiagonalBorder, spreadsheetUnderlineCellValue, normalizeSpreadsheetDataValidationErrorStyle, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextColor, isHighSurrogate, xlsxNativeFillCellKeys, createOfficeSpreadsheetCollaborationBinding as createWorkOfficeSpreadsheetCollaborationBinding, boundedSpreadsheetDataValidationText, normalizeXlsxRichTextCell, activeXlsxNativeFill, spreadsheetUnderlineStyle, normalizeSpreadsheetDateValidationBoundary, deleteXlsxNativeFills, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, normalizeXlsxRichTextRun, spreadsheetDiagonalBorderFromCellValue, sameXlsxRichTextRunStyle, isLowSurrogate, spreadsheetTextOrientationFromCell, coalesceXlsxRichTextRuns, patchSpreadsheetRichTextFontRuns, fillSpreadsheetTableCalculatedColumns, validXlsxRichText, replaceOfficeSpreadsheetCollaboration as replaceWorkOfficeSpreadsheetCollaboration, isSpreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell } from "./3266.js";
 import { moveOfficeMenuFocus, stepOfficeZoom, useOfficeRemoteParticipants, Popover, Dialog, officePresenceColor, useOfficePublishPresenceLocation, button_Button, icon_button_IconButton, moveOfficeGridMenuFocus, office_text_field_OfficeTextField, useDialogFocusScope, useOfficeEditorWheelZoom } from "./0~8136.js";
 import { isOfficeKernelSpreadsheetError, normalizeCssColor, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, createOfficeId as createWorkId } from "./4121.js";
 import { useOfficeTaskPaneEscape, OfficeCheckbox, CommittedOfficeNumberField, useOfficeDialog, useOfficeTaskPaneModal, createOfficeKernelClient, officeFontFamilies, CollectionState, OfficeNumberField, handleOfficeTaskPaneKeyDown } from "./0~7048.js";
@@ -3769,12 +3769,22 @@ function reconcileSpreadsheetTablesAfterFortune(sheets, sourceSheets, operations
         const sheetOperations = operations.filter((operation)=>operation.id === source.id);
         let tables = source.tables;
         const reconcileColumns = new Set();
+        const calculatedColumnRows = new Map();
         if (!operations.length) for (const table of tables)reconcileColumns.add(table.id);
         for (const operation of sheetOperations){
             const structure = spreadsheetTableStructureChangeFromOperation(operation);
             if (structure) {
+                transformCalculatedColumnRows(calculatedColumnRows, structure);
                 const transformed = [];
                 for (const table of tables){
+                    if ('row' === structure.axis && 'insert' === structure.kind) {
+                        const insertedRows = rowsInsertedIntoSpreadsheetTableBody(table, structure);
+                        if (insertedRows.length) {
+                            const rows = calculatedColumnRows.get(table.id) ?? new Set();
+                            for (const row of insertedRows)rows.add(row);
+                            calculatedColumnRows.set(table.id, rows);
+                        }
+                    }
                     const next = transformSpreadsheetTableStructure(table, structure);
                     if (next) {
                         transformed.push(next);
@@ -3786,7 +3796,7 @@ function reconcileSpreadsheetTablesAfterFortune(sheets, sourceSheets, operations
             }
             const coordinate = spreadsheetCellCoordinateFromOperation(operation);
             if (!coordinate) continue;
-            const table = tables.find((candidate)=>candidate.headerRow && candidate.range.row[0] === coordinate.row && coordinate.column >= candidate.range.column[0] && coordinate.column <= candidate.range.column[1]);
+            const table = tables.find((candidate)=>spreadsheetTableContainsCell(candidate, coordinate.row, coordinate.column));
             if (table) reconcileColumns.add(table.id);
         }
         const updates = [];
@@ -3794,7 +3804,11 @@ function reconcileSpreadsheetTablesAfterFortune(sheets, sourceSheets, operations
         tables = tables.map((table)=>{
             if (!reconcileColumns.has(table.id)) return table;
             const columns = canonicalSpreadsheetTableColumns(table, readCell);
-            if (table.headerRow) for (const [offset, column] of columns.entries()){
+            const calculatedColumns = reconcileSpreadsheetTableCalculatedColumns(sheet, {
+                ...table,
+                columns
+            });
+            if (table.headerRow) for (const [offset, column] of calculatedColumns.entries()){
                 const cellColumn = table.range.column[0] + offset;
                 if (spreadsheetCellText(readCell(table.range.row[0], cellColumn)) !== column.name) updates.push({
                     column: cellColumn,
@@ -3802,12 +3816,19 @@ function reconcileSpreadsheetTablesAfterFortune(sheets, sourceSheets, operations
                     row: table.range.row[0]
                 });
             }
-            return sameSpreadsheetTableColumns(table.columns, columns) ? table : {
+            return sameSpreadsheetTableColumns(table.columns, calculatedColumns) ? table : {
                 ...table,
-                columns
+                columns: calculatedColumns
             };
         });
-        const withHeaders = stampSpreadsheetTableHeaderCells(sheet, updates);
+        let withCalculatedColumns = sheet;
+        for (const table of tables){
+            const rows = calculatedColumnRows.get(table.id);
+            if (rows?.size) withCalculatedColumns = fillSpreadsheetTableCalculatedColumns(withCalculatedColumns, table, [
+                ...rows
+            ]);
+        }
+        const withHeaders = stampSpreadsheetTableHeaderCells(withCalculatedColumns, updates);
         return {
             ...withHeaders,
             tables: tables.length ? tables : void 0
@@ -3870,6 +3891,39 @@ function transformSpreadsheetTableStructure(table, change) {
         filters: filtersAfterSpreadsheetTableColumnDeletion(table.filters, transformed.offset, removed)
     };
 }
+function spreadsheetTableContainsCell(table, row, column) {
+    return row >= table.range.row[0] && row <= table.range.row[1] && column >= table.range.column[0] && column <= table.range.column[1];
+}
+function rowsInsertedIntoSpreadsheetTableBody(table, change) {
+    if ('row' !== change.axis) return [];
+    const transformed = transformSpreadsheetTableAxisForInsertion(table.range.row, change);
+    if (!transformed.inside) return [];
+    const insertion = change.index + ('rightbottom' === change.direction ? 1 : 0);
+    const bodyStart = table.range.row[0] + Number(table.headerRow);
+    if (insertion < bodyStart) return [];
+    return Array.from({
+        length: change.count
+    }, (_, offset)=>insertion + offset);
+}
+function transformCalculatedColumnRows(rowsByTable, change) {
+    if ('row' !== change.axis || !rowsByTable.size) return;
+    if ('insert' === change.kind) {
+        const insertion = change.index + ('rightbottom' === change.direction ? 1 : 0);
+        for (const [tableId, rows] of rowsByTable){
+            const next = new Set();
+            for (const row of rows)next.add(row >= insertion ? row + change.count : row);
+            rowsByTable.set(tableId, next);
+        }
+        return;
+    }
+    const count = change.end - change.start + 1;
+    for (const [tableId, rows] of rowsByTable){
+        const next = new Set();
+        for (const row of rows)if (row < change.start) next.add(row);
+        else if (row > change.end) next.add(row - count);
+        rowsByTable.set(tableId, next);
+    }
+}
 function transformSpreadsheetTableAxisForInsertion(axis, change) {
     const start = axis[0] ?? 0;
     const end = axis[1] ?? start;
@@ -4092,7 +4146,7 @@ function truncateSpreadsheetTableColumnName(value, maximum) {
     return Array.from(value).slice(0, maximum).join('');
 }
 function sameSpreadsheetTableColumns(left, right) {
-    return left.length === right.length && left.every((column, index)=>column.name === right[index]?.name);
+    return left.length === right.length && left.every((column, index)=>column.name === right[index]?.name && column.calculatedFormula === right[index]?.calculatedFormula);
 }
 function spreadsheet_table_reconciliation_isRecord(value) {
     return Boolean(value && 'object' == typeof value && !Array.isArray(value));
@@ -9378,7 +9432,7 @@ function applySpreadsheetTable(content, request) {
         family: 'medium',
         number: 2
     };
-    const table = {
+    const tableWithoutCalculatedColumns = {
         id: createWorkId('spreadsheet-table'),
         name: validation.name,
         range: cloneRange(validation.range),
@@ -9394,6 +9448,10 @@ function applySpreadsheetTable(content, request) {
         showRowStripes: 'none' !== style.family,
         showColumnStripes: false
     };
+    const table = {
+        ...tableWithoutCalculatedColumns,
+        columns: reconcileSpreadsheetTableCalculatedColumns(validation.sheet, tableWithoutCalculatedColumns)
+    };
     const nextSheet = request.headerRow ? stampSpreadsheetTableHeaders(validation.sheet, validation.range, validation.columns) : validation.sheet;
     return replaceSpreadsheetTableSheet(content, {
         ...nextSheet,
@@ -10444,9 +10502,9 @@ function createSpreadsheetFormulaDiagnostics(content, { summary, locations }) {
     });
     if (summary.structuredReferenceCells) diagnostics.push({
         code: 'formula.structured-references',
-        severity: 'warning',
+        severity: 'info',
         title: '结构化引用',
-        message: `${summary.structuredReferenceCells} 个公式使用表格结构化引用；公式会原样保存，但当前计算引擎不解析 Excel 表对象。`,
+        message: `${summary.structuredReferenceCells} 个公式使用表格结构化引用；浏览器内核支持有界表名、显示名称、连续列范围以及常见标题、数据、汇总和当前行选择。不连续、外部或高级形式会保留公式与缓存值，交由兼容应用重算。`,
         locations: locations.structured
     });
     if (summary.unsupportedFunctions.length) diagnostics.push({
@@ -21908,10 +21966,15 @@ function compileSpreadsheetKernelWorkbook(sheets, fallbackCells = []) {
         cellCount += cells.length;
         sheetIds.add(id);
         sheetNames.add(normalizedName);
+        const tables = spreadsheetKernelTables(sheet.tables);
+        if (null === tables) return null;
         sourceSheets.push({
             id,
             name,
-            cells
+            cells,
+            ...tables.length ? {
+                tables
+            } : {}
         });
     }
     const compiled = sourceSheets.map((sheet)=>({
@@ -21954,7 +22017,8 @@ function spreadsheetKernelSourceState(sheets) {
         sourceCells,
         structureKey: JSON.stringify(sheets.map((sheet)=>({
                 id: sheet.id,
-                name: sheet.name
+                name: sheet.name,
+                tables: sheet.tables ?? []
             })))
     };
 }
@@ -21972,7 +22036,18 @@ function spreadsheetStructureKey(sheets) {
         names.add(normalizedName);
         structure.push({
             id,
-            name
+            name,
+            tables: (sheet.tables ?? []).map((table)=>({
+                    name: table.name,
+                    displayName: table.displayName,
+                    startRow: table.range.row[0],
+                    endRow: table.range.row[1],
+                    startColumn: table.range.column[0],
+                    endColumn: table.range.column[1],
+                    columns: table.columns.map((column)=>column.name),
+                    headerRow: table.headerRow,
+                    totalsRow: table.totalsRow
+                }))
         });
     }
     return JSON.stringify(structure);
@@ -22055,6 +22130,49 @@ function spreadsheetKernelInputCell(cell, fallback) {
     const { formula: _formula, ...cachedCell } = cell;
     return cachedCell;
 }
+function spreadsheetKernelTables(tables) {
+    if (!tables?.length) return [];
+    const names = new Map();
+    const ranges = [];
+    for (const [tableIndex, table] of tables.entries()){
+        const [startRow, endRow] = table.range.row;
+        const [startColumn, endColumn] = table.range.column;
+        if (!table.name?.trim() || utf8ByteLength(table.name) > SPREADSHEET_KERNEL_MAX_IDENTIFIER_BYTES || void 0 !== table.displayName && (!table.displayName.trim() || utf8ByteLength(table.displayName) > SPREADSHEET_KERNEL_MAX_IDENTIFIER_BYTES) || !isSpreadsheetCoordinateIndex(startRow, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) || !isSpreadsheetCoordinateIndex(endRow, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) || !isSpreadsheetCoordinateIndex(startColumn, 16384) || !isSpreadsheetCoordinateIndex(endColumn, 16384) || startRow > endRow || startColumn > endColumn || table.columns.length !== endColumn - startColumn + 1) return null;
+        for (const alias of [
+            table.name,
+            table.displayName
+        ]){
+            if (!alias) continue;
+            const normalized = alias.toLocaleLowerCase();
+            const previous = names.get(normalized);
+            if (void 0 !== previous && previous !== tableIndex) return null;
+            names.set(normalized, tableIndex);
+        }
+        const columnNames = new Set();
+        for (const column of table.columns){
+            if (!column.name?.trim() || utf8ByteLength(column.name) > SPREADSHEET_KERNEL_MAX_IDENTIFIER_BYTES) return null;
+            const normalized = column.name.toLocaleLowerCase();
+            if (columnNames.has(normalized)) return null;
+            columnNames.add(normalized);
+        }
+        const next = {
+            name: table.name,
+            ...table.displayName ? {
+                displayName: table.displayName
+            } : {},
+            startRow,
+            endRow,
+            startColumn,
+            endColumn,
+            columns: table.columns.map((column)=>column.name),
+            headerRow: Boolean(table.headerRow),
+            totalsRow: Boolean(table.totalsRow)
+        };
+        if (ranges.some((previous)=>next.startRow <= previous.endRow && next.endRow >= previous.startRow && next.startColumn <= previous.endColumn && next.endColumn >= previous.startColumn)) return null;
+        ranges.push(next);
+    }
+    return ranges;
+}
 function spreadsheetSheetsWithKernelChanges(sheets, changes) {
     const changesBySheet = new Map();
     for (const change of changes.values()){
@@ -22313,7 +22431,7 @@ function spreadsheetCalculationOps(sheets, calculatedCells) {
     });
 }
 function sameSpreadsheetStructure(previous, current) {
-    return previous.length === current.length && previous.every((sheet, index)=>sheet.id === current[index]?.id && sheet.name === current[index]?.name);
+    return previous.length === current.length && previous.every((sheet, index)=>sheet.id === current[index]?.id && sheet.name === current[index]?.name && JSON.stringify(sheet.tables ?? []) === JSON.stringify(current[index]?.tables ?? []));
 }
 function cellWithCalculatedValue(cell, value) {
     const next = {

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,178 @@
+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;
+}
 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 +426,29 @@ 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'
         ], `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 {
+        if (void 0 === record.calculatedFormula) return {
             name
         };
+        const calculatedFormula = normalizeSpreadsheetTableCalculatedFormula(record.calculatedFormula);
+        if (!calculatedFormula || calculatedFormula !== record.calculatedFormula) invalidWorkOfficeSpreadsheetInput(`a bounded structured calculated-column formula for ${label}`);
+        return {
+            name,
+            calculatedFormula
+        };
     });
 }
+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 +923,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 +1033,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 +2395,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 +2420,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 +2563,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 { activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, coalesceXlsxRichTextRuns, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, fillSpreadsheetTableCalculatedColumns, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isHighSurrogate, isLowSurrogate, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetTableCalculatedFormula, normalizeXlsxRichTextCell, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextRun, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, reconcileSpreadsheetTableCalculatedColumns, 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 };