@a3s-lab/office 0.15.0 → 0.16.0

package/dist/0~spreadsheet-editor.js

@@ -10,13 +10,13 @@ import { moveOfficeMenuFocus, stepOfficeZoom, useOfficeRemoteParticipants, Popov
 import { useOfficeTaskPaneEscape, OfficeCheckbox, CommittedOfficeNumberField, useOfficeDialog, useOfficeTaskPaneModal, createOfficeKernelClient, officeFontFamilies, CollectionState, OfficeNumberField, handleOfficeTaskPaneKeyDown } from "./0~7048.js";
 import { isOfficeShortcutBlocked, OfficeColorPicker } from "./0~3635.js";
 import { createOfficeEditorExtension, useOfficeEditorRuntime, useOfficeEditorKeyboardShortcuts } from "./0~3557.js";
+import { OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, createOfficeId as createWorkId, isOfficeKernelSpreadsheetError } from "./5184.js";
 import { showToast } from "./6489.js";
 import { unsupportedSpreadsheetFormulaFunctions } from "./0~work-spreadsheet-formula-support.js";
 import { WorkspaceContextMenu, isWorkspaceContextMenuKeyboardEvent, WorkOfficeZoomControls, Tabs, WorkOfficeStatusBar, Dialog, WorkOfficeRibbon, workspaceContextMenuPosition, OfficeSelect, WorkOfficeRibbonGroup, WorkOfficeRibbonButton, WorkOfficePreviewBar } from "./0~4595.js";
 import { useOfficeDraft, InlineNotice } from "./0~345.js";
 import { spreadsheetAgentMenuItems, SpreadsheetChartSeriesStyleEditor, normalizeOptionalOfficeNumber, normalizeRequiredOfficeNumber, SpreadsheetErrorBarEditor, useOfficeHistory, spreadsheetAgentSelection, SpreadsheetTrendlineEditor, applySpreadsheetAgentProposalChanges } from "./0~3539.js";
 import { useOfficeEditorFocusOrigin, useOfficeCollaborationLocationNavigator, StateView } from "./432.js";
-import { OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, createOfficeId as createWorkId, isOfficeKernelSpreadsheetError } from "./5184.js";
 var spreadsheet_editor_namespaceObject = {};
 __webpack_require__.r(spreadsheet_editor_namespaceObject);
 __webpack_require__.d(spreadsheet_editor_namespaceObject, {
@@ -1357,6 +1357,349 @@ function isSpreadsheetCoordinate(value) {
 function positiveSpreadsheetDimension(value) {
     return 'number' == typeof value && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
 }
+function canApplySpreadsheetTableStructureChange(sheet, change) {
+    if (!sheet || !validSpreadsheetTableStructureChange(change)) return false;
+    for (const table of sheet.tables ?? []){
+        if ('delete' === change.kind && 'row' === change.axis && spreadsheetTableDeleteRemovesSemanticRow(table, change.start, change.end)) return false;
+        if (!transformSpreadsheetTableStructure(table, change)) return false;
+    }
+    return true;
+}
+function reconcileSpreadsheetTablesAfterFortune(sheets, sourceSheets, operations = []) {
+    return sheets.map((sheet, index)=>{
+        const source = sourceSheetForReconciliation(sheet, sourceSheets, index);
+        if (!source?.tables?.length) return sheet;
+        const sheetOperations = operations.filter((operation)=>operation.id === source.id);
+        let tables = source.tables;
+        const reconcileColumns = new Set();
+        if (!operations.length) for (const table of tables)reconcileColumns.add(table.id);
+        for (const operation of sheetOperations){
+            const structure = spreadsheetTableStructureChangeFromOperation(operation);
+            if (structure) {
+                const transformed = [];
+                for (const table of tables){
+                    const next = transformSpreadsheetTableStructure(table, structure);
+                    if (next) {
+                        transformed.push(next);
+                        if (next !== table) reconcileColumns.add(table.id);
+                    }
+                }
+                tables = transformed;
+                continue;
+            }
+            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]);
+            if (table) reconcileColumns.add(table.id);
+        }
+        const updates = [];
+        const readCell = spreadsheetSheetCellReader(sheet);
+        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 cellColumn = table.range.column[0] + offset;
+                if (spreadsheetCellText(readCell(table.range.row[0], cellColumn)) !== column.name) updates.push({
+                    column: cellColumn,
+                    name: column.name,
+                    row: table.range.row[0]
+                });
+            }
+            return sameSpreadsheetTableColumns(table.columns, columns) ? table : {
+                ...table,
+                columns
+            };
+        });
+        const withHeaders = stampSpreadsheetTableHeaderCells(sheet, updates);
+        return {
+            ...withHeaders,
+            tables: tables.length ? tables : void 0
+        };
+    });
+}
+function transformSpreadsheetTableStructure(table, change) {
+    if (!validSpreadsheetTableStructureChange(change)) return null;
+    const axis = 'row' === change.axis ? table.range.row : table.range.column;
+    const transformed = 'insert' === change.kind ? transformSpreadsheetTableAxisForInsertion(axis, change) : transformSpreadsheetTableAxisForDeletion(axis, change);
+    if (!transformed) return null;
+    const range = {
+        row: 'row' === change.axis ? transformed.axis : [
+            ...table.range.row
+        ],
+        column: 'column' === change.axis ? transformed.axis : [
+            ...table.range.column
+        ]
+    };
+    const height = range.row[1] - range.row[0] + 1;
+    if (height <= Number(table.headerRow) + Number(table.totalsRow)) return null;
+    if ('column' !== change.axis || !transformed.inside) {
+        if (range.row[0] === table.range.row[0] && range.row[1] === table.range.row[1] && range.column[0] === table.range.column[0] && range.column[1] === table.range.column[1]) return table;
+        return {
+            ...table,
+            range
+        };
+    }
+    if ('insert' === change.kind) {
+        const columns = [
+            ...table.columns
+        ];
+        columns.splice(transformed.offset, 0, ...Array.from({
+            length: change.count
+        }, ()=>({
+                name: ''
+            })));
+        return {
+            ...table,
+            range,
+            columns,
+            filters: table.filters.map((filter)=>filter.column >= transformed.offset ? {
+                    ...filter,
+                    column: filter.column + change.count
+                } : filter)
+        };
+    }
+    if (!('removed' in transformed)) return null;
+    const removed = transformed.removed;
+    if ('number' != typeof removed) return null;
+    const columns = [
+        ...table.columns
+    ];
+    columns.splice(transformed.offset, removed);
+    if (!columns.length) return null;
+    return {
+        ...table,
+        range,
+        columns,
+        filters: filtersAfterSpreadsheetTableColumnDeletion(table.filters, transformed.offset, removed)
+    };
+}
+function transformSpreadsheetTableAxisForInsertion(axis, change) {
+    const start = axis[0] ?? 0;
+    const end = axis[1] ?? start;
+    const insertion = change.index + ('rightbottom' === change.direction ? 1 : 0);
+    if (insertion <= start) return {
+        axis: [
+            start + change.count,
+            end + change.count
+        ],
+        inside: false,
+        offset: 0
+    };
+    if (insertion <= end) return {
+        axis: [
+            start,
+            end + change.count
+        ],
+        inside: true,
+        offset: insertion - start
+    };
+    return {
+        axis: [
+            start,
+            end
+        ],
+        inside: false,
+        offset: 0
+    };
+}
+function transformSpreadsheetTableAxisForDeletion(axis, change) {
+    const start = axis[0] ?? 0;
+    const end = axis[1] ?? start;
+    const count = change.end - change.start + 1;
+    if (change.end < start) return {
+        axis: [
+            start - count,
+            end - count
+        ],
+        inside: false,
+        offset: 0,
+        removed: 0
+    };
+    if (change.start > end) return {
+        axis: [
+            start,
+            end
+        ],
+        inside: false,
+        offset: 0,
+        removed: 0
+    };
+    const overlapStart = Math.max(start, change.start);
+    const overlapEnd = Math.min(end, change.end);
+    const removed = overlapEnd - overlapStart + 1;
+    const remaining = end - start + 1 - removed;
+    if (remaining <= 0) return null;
+    const deletedBeforeStart = Math.max(0, Math.min(change.end, start - 1) - change.start + 1);
+    const nextStart = start - deletedBeforeStart;
+    return {
+        axis: [
+            nextStart,
+            nextStart + remaining - 1
+        ],
+        inside: true,
+        offset: overlapStart - start,
+        removed
+    };
+}
+function filtersAfterSpreadsheetTableColumnDeletion(filters, offset, removed) {
+    const end = offset + removed - 1;
+    return filters.flatMap((filter)=>{
+        if (filter.column >= offset && filter.column <= end) return [];
+        return [
+            filter.column > end ? {
+                ...filter,
+                column: filter.column - removed
+            } : filter
+        ];
+    });
+}
+function canonicalSpreadsheetTableColumns(table, readCell) {
+    const width = table.range.column[1] - table.range.column[0] + 1;
+    const observed = new Set();
+    return Array.from({
+        length: width
+    }, (_, offset)=>{
+        const raw = table.headerRow ? spreadsheetCellText(readCell(table.range.row[0], table.range.column[0] + offset)).trim() : table.columns[offset]?.name.trim() ?? '';
+        const base = validSpreadsheetTableColumnName(raw) ? raw : `Column${offset + 1}`;
+        let candidate = base;
+        let suffix = 2;
+        while(observed.has(candidate.toLocaleLowerCase())){
+            const suffixText = String(suffix);
+            candidate = `${truncateSpreadsheetTableColumnName(base, 255 - suffixText.length)}${suffixText}`;
+            suffix += 1;
+        }
+        observed.add(candidate.toLocaleLowerCase());
+        return {
+            name: candidate
+        };
+    });
+}
+function spreadsheetTableDeleteRemovesSemanticRow(table, start, end) {
+    return Boolean(table.headerRow && start <= table.range.row[0] && end >= table.range.row[0] || table.totalsRow && start <= table.range.row[1] && end >= table.range.row[1]);
+}
+function spreadsheetTableStructureChangeFromOperation(operation) {
+    if (!spreadsheet_table_reconciliation_isRecord(operation.value)) return null;
+    if ('insertRowCol' === operation.op) {
+        const { count, direction, index, type } = operation.value;
+        const change = {
+            axis: 'column' === type ? 'column' : 'row',
+            count: Number(count),
+            direction: 'rightbottom' === direction ? 'rightbottom' : 'lefttop',
+            index: Number(index),
+            kind: 'insert'
+        };
+        return ('column' === type || 'row' === type) && ('lefttop' === direction || 'rightbottom' === direction) && validSpreadsheetTableStructureChange(change) ? change : null;
+    }
+    if ('deleteRowCol' === operation.op) {
+        const { end, start, type } = operation.value;
+        const change = {
+            axis: 'column' === type ? 'column' : 'row',
+            end: Number(end),
+            kind: 'delete',
+            start: Number(start)
+        };
+        return ('column' === type || 'row' === type) && validSpreadsheetTableStructureChange(change) ? change : null;
+    }
+    return null;
+}
+function spreadsheetCellCoordinateFromOperation(operation) {
+    if ('data' !== operation.path[0] || operation.path.length < 3) return null;
+    const row = operation.path[1];
+    const column = operation.path[2];
+    return Number.isSafeInteger(row) && Number(row) >= 0 && Number.isSafeInteger(column) && Number(column) >= 0 ? {
+        column: Number(column),
+        row: Number(row)
+    } : null;
+}
+function validSpreadsheetTableStructureChange(change) {
+    if ('insert' === change.kind) return Number.isSafeInteger(change.index) && change.index >= 0 && Number.isSafeInteger(change.count) && change.count > 0;
+    return Number.isSafeInteger(change.start) && change.start >= 0 && Number.isSafeInteger(change.end) && change.end >= change.start;
+}
+function sourceSheetForReconciliation(sheet, sourceSheets, index) {
+    return (sheet.id ? sourceSheets.find((candidate)=>candidate.id === sheet.id) : void 0) ?? sourceSheets[index];
+}
+function spreadsheetSheetCellReader(sheet) {
+    if (void 0 !== sheet.data) return (row, column)=>sheet.data?.[row]?.[column] ?? null;
+    const cells = new Map((sheet.celldata ?? []).map((entry)=>[
+            `${entry.r}:${entry.c}`,
+            entry.v
+        ]));
+    return (row, column)=>cells.get(`${row}:${column}`) ?? null;
+}
+function stampSpreadsheetTableHeaderCells(sheet, updates) {
+    if (!updates.length) return sheet;
+    if (void 0 !== sheet.data) {
+        const data = [];
+        data.length = sheet.data.length;
+        for (const [row, value] of sparseArrayEntries(sheet.data))data[row] = value;
+        const mutableRows = new Map();
+        for (const update of updates){
+            let row = mutableRows.get(update.row);
+            if (!row) {
+                const source = data[update.row];
+                row = [];
+                row.length = source?.length ?? 0;
+                for (const column of sparseArrayIndexes(source))row[column] = source?.[column];
+                mutableRows.set(update.row, row);
+                data[update.row] = row;
+            }
+            row[update.column] = stampSpreadsheetTableHeaderCell(row[update.column], update.name);
+        }
+        return {
+            ...sheet,
+            data
+        };
+    }
+    const celldata = [
+        ...sheet.celldata ?? []
+    ];
+    const indexes = new Map(celldata.map((entry, index)=>[
+            `${entry.r}:${entry.c}`,
+            index
+        ]));
+    for (const update of updates){
+        const key = `${update.row}:${update.column}`;
+        const index = indexes.get(key);
+        const source = void 0 === index ? void 0 : celldata[index];
+        const entry = {
+            r: update.row,
+            c: update.column,
+            v: stampSpreadsheetTableHeaderCell(source?.v, update.name)
+        };
+        if (void 0 === index) {
+            indexes.set(key, celldata.length);
+            celldata.push(entry);
+        } else celldata[index] = entry;
+    }
+    return {
+        ...sheet,
+        celldata
+    };
+}
+function stampSpreadsheetTableHeaderCell(cell, name) {
+    return {
+        ...cell ?? {},
+        m: name,
+        v: name
+    };
+}
+function spreadsheetCellText(cell) {
+    const value = cell?.m ?? cell?.v;
+    return null == value ? '' : String(value);
+}
+function validSpreadsheetTableColumnName(name) {
+    const characters = Array.from(name);
+    return name.trim() === name && characters.length >= 1 && characters.length <= 255 && !characters.some((character)=>/\p{Cc}/u.test(character) || '\uFFFE' === character || '\uFFFF' === character);
+}
+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);
+}
+function spreadsheet_table_reconciliation_isRecord(value) {
+    return Boolean(value && 'object' == typeof value && !Array.isArray(value));
+}
 const spreadsheetFontSizes = [
     9,
     10,
@@ -1622,7 +1965,7 @@ function spreadsheetSheetsFromFortune(sheets, sourceSheets, operations = []) {
             incremental: true,
             operationCount: operations.length
         });
-        return incremental.sheets;
+        return reconcileSpreadsheetTablesAfterFortune(incremental.sheets, sourceSheets, operations);
     }
     const projected = sheets.map((sheet, index)=>{
         const source = (sheet.id ? sourceSheets.find((candidate)=>candidate.id === sheet.id) : void 0) ?? sourceSheets[index];
@@ -1651,7 +1994,7 @@ function spreadsheetSheetsFromFortune(sheets, sourceSheets, operations = []) {
         incremental: false,
         operationCount: operations.length
     });
-    return projected;
+    return reconcileSpreadsheetTablesAfterFortune(projected, sourceSheets, operations);
 }
 function recordSpreadsheetControlledProjectionMeasure(start, end, detail) {
     try {
@@ -2289,6 +2632,12 @@ const spreadsheetRibbonTabs = [
         label: '视图'
     }
 ];
+const spreadsheetTableDesignRibbonTab = {
+    id: 'tableDesign',
+    label: '表格设计',
+    compactLabel: '设计',
+    contextual: true
+};
 const spreadsheetCommandCatalog = {
     undo: {
         id: 'history.undo',
@@ -3058,6 +3407,22 @@ const spreadsheetCommandCatalog = {
             group: 'charts'
         }
     },
+    table: {
+        id: 'insert.table',
+        label: '表格',
+        location: {
+            area: 'ribbon',
+            tab: 'insert',
+            group: 'tables'
+        },
+        shortcut: {
+            label: 'Cmd/Ctrl+T',
+            aria: 'Control+T Meta+T',
+            editor: [
+                'Mod-t'
+            ]
+        }
+    },
     hyperlink: {
         id: 'insert.hyperlink',
         label: '超链接',
@@ -5048,11 +5413,15 @@ function canApplySpreadsheetCellMerge(sheet, range, command) {
     const merged = spreadsheetMergesIntersectingRange(sheet, normalized);
     if ('unmerge-cells' === command || 'unmerge-and-fill' === command) return merged.length > 0;
     if (merged.length > 0) return false;
+    if (spreadsheetMergeIntersectsTable(sheet, normalized)) return false;
     const rowCount = normalized.row[1] - normalized.row[0] + 1;
     const columnCount = normalized.column[1] - normalized.column[0] + 1;
     if ('merge-across' === command) return columnCount > 1;
     return rowCount * columnCount > 1;
 }
+function spreadsheetMergeIntersectsTable(sheet, range) {
+    return (sheet.tables ?? []).some((table)=>table.range.row[0] <= range.row[1] && table.range.row[1] >= range.row[0] && table.range.column[0] <= range.column[1] && table.range.column[1] >= range.column[0]);
+}
 function spreadsheetCellMergeApiCalls(sheet, sheetId, range, command) {
     if (!canApplySpreadsheetCellMerge(sheet, range, command) || !sheet) return [];
     const normalized = normalizeSpreadsheetCellMergeRange(range);
@@ -5991,147 +6360,1040 @@ function spreadsheetSelectionAfterStructureDeletion(selection, axis, extent, sta
         }
     };
 }
-function createSpreadsheetEditorExtensions() {
-    return [
-        createOfficeEditorExtension({
-            name: 'spreadsheetDocument',
-            addCommands: ()=>({
-                    setSpreadsheetContent: {
-                        canExecute: (context)=>context.editable,
-                        execute: (context, content)=>{
-                            if (!context.editable) return false;
-                            context.onChange(content);
-                            return true;
-                        }
-                    }
-                })
-        }),
-        createSpreadsheetCellFormatExtension(),
-        createSpreadsheetCellBorderExtension(),
-        createSpreadsheetCellStyleExtension(),
-        createSpreadsheetNumberFormatExtension(),
-        createSpreadsheetNavigationExtension(),
-        createSpreadsheetDataValidationExtension(),
-        createSpreadsheetHyperlinkExtension(),
-        createSpreadsheetAutoSumExtension(),
-        createSpreadsheetCellFillExtension(),
-        createOfficeEditorExtension({
-            name: 'spreadsheetFormatPainter',
-            addCommands: ()=>({
-                    activateFormatPainter: {
-                        canExecute: ({ formatPainter })=>formatPainter.canActivate,
-                        execute: ({ formatPainter }, mode)=>formatPainter.canActivate && formatPainter.activate(mode)
-                    },
-                    applyFormatPainter: {
-                        canExecute: ({ formatPainter })=>formatPainter.active,
-                        execute: ({ formatPainter }, target)=>formatPainter.active && formatPainter.applySelection(target)
-                    },
-                    cancelFormatPainter: {
-                        canExecute: ({ formatPainter })=>formatPainter.active,
-                        execute: ({ formatPainter })=>formatPainter.active && formatPainter.cancel()
-                    }
-                })
-        }),
-        createOfficeEditorExtension({
-            name: 'spreadsheetAutoFilter',
-            addCommands: ()=>({
-                    openAutoFilterMenu: {
-                        canExecute: ({ autoFilter })=>autoFilter.canOpenMenu,
-                        execute: ({ autoFilter })=>autoFilter.canOpenMenu && autoFilter.openMenu()
-                    },
-                    toggleAutoFilter: {
-                        canExecute: ({ autoFilter })=>autoFilter.canToggle,
-                        execute: ({ autoFilter })=>autoFilter.canToggle && autoFilter.toggle()
-                    }
-                })
-        }),
-        createOfficeEditorExtension({
-            name: 'spreadsheetClipboard',
-            addCommands: ()=>({
-                    copySelection: {
-                        canExecute: ({ clipboard })=>clipboard.canCopySelection,
-                        execute: ({ clipboard })=>clipboard.canCopySelection && clipboard.copySelection()
-                    },
-                    cutSelection: {
-                        canExecute: ({ clipboard })=>clipboard.canCutSelection,
-                        execute: ({ clipboard })=>clipboard.canCutSelection && clipboard.cutSelection()
-                    },
-                    pasteSelection: {
-                        canExecute: ({ clipboard })=>clipboard.canPasteSelection,
-                        execute: ({ clipboard })=>clipboard.canPasteSelection && clipboard.pasteSelection()
-                    },
-                    pasteSpecial: {
-                        canExecute: ({ clipboard }, content)=>clipboard.canPasteSpecial(content),
-                        execute: ({ clipboard }, content)=>clipboard.canPasteSpecial(content) && clipboard.pasteSpecial(content)
-                    },
-                    openPasteSpecial: {
-                        canExecute: ({ clipboard })=>clipboard.canOpenPasteSpecial,
-                        execute: ({ clipboard })=>clipboard.canOpenPasteSpecial && clipboard.openPasteSpecial()
-                    }
-                })
-        }),
-        createOfficeEditorExtension({
-            name: 'spreadsheetHistory',
-            addCommands: ()=>({
-                    redo: {
-                        canExecute: (context)=>context.editable && (context.history?.canRedo ?? false),
-                        execute: (context)=>context.history?.redo() ?? false
-                    },
-                    undo: {
-                        canExecute: (context)=>context.editable && (context.history?.canUndo ?? false),
-                        execute: (context)=>context.history?.undo() ?? false
-                    }
-                })
-        }),
-        createOfficeEditorExtension({
-            name: 'spreadsheetSheets',
-            addCommands: ()=>({
-                    activateSheet: {
-                        canExecute: (context, sheetId)=>{
-                            const sheet = context.content.sheets.find((candidate)=>candidate.id === sheetId);
-                            return Boolean(sheet && (context.editable || context.view && 1 !== sheet.hide));
-                        },
-                        execute: (context, sheetId)=>{
-                            const sheet = context.content.sheets.find((candidate)=>candidate.id === sheetId);
-                            if (!sheet) return false;
-                            if (context.view && 1 !== sheet.hide) return context.view?.activateSheet(sheetId) ?? false;
-                            if (!context.editable) return false;
-                            return applySpreadsheetSheetChange(context, activateSpreadsheetSheet(context.content, sheetId));
-                        }
-                    },
-                    addSheet: {
-                        canExecute: (context)=>context.editable,
-                        execute: (context)=>applySpreadsheetSheetChange(context, addSpreadsheetSheet(context.content))
-                    },
-                    deleteSheet: {
-                        canExecute: (context, sheetId)=>Boolean(context.editable && context.content.sheets.length > 1 && context.content.sheets.some((sheet)=>sheet.id === sheetId)),
-                        execute: (context, sheetId)=>applySpreadsheetSheetChange(context, deleteSpreadsheetSheet(context.content, sheetId))
-                    },
-                    duplicateSheet: {
-                        canExecute: (context, sheetId)=>context.editable && context.content.sheets.some((sheet)=>sheet.id === sheetId),
-                        execute: (context, sheetId)=>applySpreadsheetSheetChange(context, duplicateSpreadsheetSheet(context.content, sheetId))
-                    },
-                    hideSheet: {
-                        canExecute: (context, sheetId)=>context.editable && context.content.sheets.filter((sheet)=>1 !== sheet.hide).length > 1 && context.content.sheets.some((sheet)=>sheet.id === sheetId && 1 !== sheet.hide),
-                        execute: (context, sheetId)=>applySpreadsheetSheetChange(context, hideSpreadsheetSheet(context.content, sheetId, true))
-                    },
-                    moveSheet: {
-                        canExecute: (context, sheetId, direction)=>Boolean(context.editable && moveSpreadsheetSheet(context.content, sheetId, direction)),
-                        execute: (context, sheetId, direction)=>applySpreadsheetSheetChange(context, moveSpreadsheetSheet(context.content, sheetId, direction))
-                    },
-                    renameSheet: {
-                        canExecute: (context, sheetId, name)=>Boolean(context.editable && renameSpreadsheetSheet(context.content, sheetId, name)),
-                        execute: (context, sheetId, name)=>applySpreadsheetSheetChange(context, renameSpreadsheetSheet(context.content, sheetId, name))
-                    },
-                    setSheetColor: {
-                        canExecute: (context, sheetId, color)=>Boolean(context.editable && setSpreadsheetSheetColor(context.content, sheetId, color)),
-                        execute: (context, sheetId, color)=>applySpreadsheetSheetChange(context, setSpreadsheetSheetColor(context.content, sheetId, color))
-                    }
-                })
-        }),
-        createOfficeEditorExtension({
-            name: 'spreadsheetKeyboardShortcuts',
-            addKeyboardShortcuts: ()=>({
+function spreadsheetAutoFilterRange(sheet, selection) {
+    const range = spreadsheetSelectionOrCurrentRegion(sheet, selection);
+    if (!range || !validSpreadsheetAutoFilterRange(sheet, range)) return null;
+    return range;
+}
+function spreadsheetSelectionOrCurrentRegion(sheet, selection) {
+    if (sheet.isPivotTable || sheet.pivotTables?.length) return null;
+    const normalized = normalizeAutoFilterSelection(selection);
+    return normalized.row[0] !== normalized.row[1] ? normalized : spreadsheetCurrentRegion(sheet, normalized);
+}
+function spreadsheetAutoFilterHeaderColumn(sheet, selection) {
+    const range = normalizedFilterSelection(sheet?.filter_select);
+    if (!sheet || !range) return null;
+    const row = spreadsheet_auto_filter_finiteIndex(selection.row_focus, selection.row[0]);
+    const column = spreadsheet_auto_filter_finiteIndex(selection.column_focus, selection.column[0]);
+    if (row !== range.row[0] || column < range.column[0] || column > range.column[1]) return null;
+    return column;
+}
+function toggleSpreadsheetAutoFilter(content, sheetId, selection) {
+    const sheetIndex = content.sheets.findIndex((sheet)=>sheet.id === sheetId);
+    const sheet = content.sheets[sheetIndex];
+    if (!sheet) return null;
+    const nextSheet = sheet.filter_select ? spreadsheetSheetWithoutAutoFilter(sheet) : spreadsheetSheetWithAutoFilter(sheet, selection);
+    if (!nextSheet) return null;
+    const sheets = [
+        ...content.sheets
+    ];
+    sheets[sheetIndex] = {
+        ...nextSheet,
+        luckysheet_select_save: [
+            finiteSpreadsheetSelection(selection)
+        ]
+    };
+    return {
+        ...content,
+        sheets
+    };
+}
+function spreadsheetSheetWithAutoFilter(sheet, selection) {
+    const range = spreadsheetAutoFilterRange(sheet, selection);
+    if (!range) return null;
+    return {
+        ...sheet,
+        filter: {},
+        filter_select: {
+            row: [
+                ...range.row
+            ],
+            column: [
+                ...range.column
+            ]
+        }
+    };
+}
+function spreadsheetSheetWithoutAutoFilter(sheet) {
+    const hiddenByFilter = spreadsheetFilterHiddenRows(sheet.filter);
+    const rowhidden = {
+        ...sheet.config?.rowhidden
+    };
+    for (const row of hiddenByFilter)delete rowhidden[row];
+    const config = sheet.config ? {
+        ...sheet.config,
+        rowhidden
+    } : void 0;
+    const { filter: _filter, filter_select: _selection, ...remaining } = sheet;
+    return {
+        ...remaining,
+        config
+    };
+}
+function spreadsheetFilterHiddenRows(filter) {
+    const rows = new Set();
+    for (const value of Object.values(filter ?? {})){
+        if (!value || 'object' != typeof value) continue;
+        const rowhidden = value.rowhidden;
+        if (rowhidden && 'object' == typeof rowhidden) for (const row of Object.keys(rowhidden))rows.add(row);
+    }
+    return rows;
+}
+function spreadsheetCurrentRegion(sheet, selection) {
+    const cells = spreadsheetCellReader(sheet);
+    const bounds = spreadsheetUsedBounds(sheet);
+    let startRow = selection.row[0];
+    let endRow = selection.row[1];
+    let startColumn = selection.column[0];
+    let endColumn = selection.column[1];
+    if (startRow > bounds.lastRow || startColumn > bounds.lastColumn || !spreadsheet_auto_filter_spreadsheetCellHasContent(cells(startRow, startColumn))) return null;
+    let changed = true;
+    while(changed){
+        changed = false;
+        while(startColumn > 0 && spreadsheetColumnHasContent(cells, startColumn - 1, startRow, endRow)){
+            startColumn -= 1;
+            changed = true;
+        }
+        while(endColumn < bounds.lastColumn && spreadsheetColumnHasContent(cells, endColumn + 1, startRow, endRow)){
+            endColumn += 1;
+            changed = true;
+        }
+        while(startRow > 0 && spreadsheetRowHasContent(cells, startRow - 1, startColumn, endColumn)){
+            startRow -= 1;
+            changed = true;
+        }
+        while(endRow < bounds.lastRow && spreadsheetRowHasContent(cells, endRow + 1, startColumn, endColumn)){
+            endRow += 1;
+            changed = true;
+        }
+    }
+    return {
+        row: [
+            startRow,
+            endRow
+        ],
+        column: [
+            startColumn,
+            endColumn
+        ]
+    };
+}
+function validSpreadsheetAutoFilterRange(sheet, range) {
+    if (range.row[1] <= range.row[0]) return false;
+    if (spreadsheetAutoFilterIntersectsTable(sheet, range)) return false;
+    const cells = spreadsheetCellReader(sheet);
+    if (!spreadsheetRowHasContent(cells, range.row[0], range.column[0], range.column[1])) return false;
+    let dataFound = false;
+    for(let row = range.row[0] + 1; row <= range.row[1]; row += 1)if (spreadsheetRowHasContent(cells, row, range.column[0], range.column[1])) {
+        dataFound = true;
+        break;
+    }
+    return dataFound && !spreadsheetRangeIntersectsMerge(sheet, range);
+}
+function spreadsheetAutoFilterIntersectsTable(sheet, range) {
+    return (sheet.tables ?? []).some((table)=>table.range.row[0] <= range.row[1] && table.range.row[1] >= range.row[0] && table.range.column[0] <= range.column[1] && table.range.column[1] >= range.column[0]);
+}
+function spreadsheetRangeIntersectsMerge(sheet, range) {
+    return Object.values(sheet.config?.merge ?? {}).some((merge)=>{
+        const endRow = merge.r + Math.max(merge.rs, 1) - 1;
+        const endColumn = merge.c + Math.max(merge.cs, 1) - 1;
+        return merge.r <= range.row[1] && endRow >= range.row[0] && merge.c <= range.column[1] && endColumn >= range.column[0];
+    });
+}
+function spreadsheetRowHasContent(cellAt, row, startColumn, endColumn) {
+    for(let column = startColumn; column <= endColumn; column += 1)if (spreadsheet_auto_filter_spreadsheetCellHasContent(cellAt(row, column))) return true;
+    return false;
+}
+function spreadsheetColumnHasContent(cellAt, column, startRow, endRow) {
+    for(let row = startRow; row <= endRow; row += 1)if (spreadsheet_auto_filter_spreadsheetCellHasContent(cellAt(row, column))) return true;
+    return false;
+}
+function spreadsheet_auto_filter_spreadsheetCellHasContent(cell) {
+    if (!cell) return false;
+    return [
+        cell.v,
+        cell.m,
+        cell.f
+    ].some((value)=>null != value && '' !== value);
+}
+function spreadsheetCellReader(sheet) {
+    if (sheet.data) return (row, column)=>sheet.data?.[row]?.[column] ?? null;
+    const cells = new Map((sheet.celldata ?? []).map((cell)=>[
+            `${cell.r}:${cell.c}`,
+            cell.v
+        ]));
+    return (row, column)=>cells.get(`${row}:${column}`) ?? null;
+}
+function spreadsheetUsedBounds(sheet) {
+    let lastRow = Math.max((sheet.data?.length ?? 1) - 1, 0);
+    let lastColumn = Math.max(sparseMatrixColumnCount(sheet.data) - 1, 0);
+    for (const cell of sheet.celldata ?? []){
+        lastRow = Math.max(lastRow, cell.r);
+        lastColumn = Math.max(lastColumn, cell.c);
+    }
+    return {
+        lastColumn,
+        lastRow
+    };
+}
+function normalizeAutoFilterSelection(selection) {
+    const startRow = spreadsheet_auto_filter_finiteIndex(selection.row[0], 0);
+    const endRow = spreadsheet_auto_filter_finiteIndex(selection.row[1], startRow);
+    const startColumn = spreadsheet_auto_filter_finiteIndex(selection.column[0], 0);
+    const endColumn = spreadsheet_auto_filter_finiteIndex(selection.column[1], startColumn);
+    return {
+        row: [
+            Math.min(startRow, endRow),
+            Math.max(startRow, endRow)
+        ],
+        column: [
+            Math.min(startColumn, endColumn),
+            Math.max(startColumn, endColumn)
+        ]
+    };
+}
+function normalizedFilterSelection(selection) {
+    if (!selection?.row?.length || !selection.column?.length) return null;
+    return normalizeAutoFilterSelection(selection);
+}
+function spreadsheet_auto_filter_finiteIndex(value, fallback) {
+    return 'number' == typeof value && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : fallback;
+}
+const ACCENTS = [
+    '#64748b',
+    '#2563eb',
+    '#0f766e',
+    '#7c3aed',
+    '#c2410c',
+    '#be123c',
+    '#15803d'
+];
+const DARK_ACCENTS = [
+    '#1e293b',
+    '#1e3a8a',
+    '#134e4a',
+    '#4c1d95',
+    '#7c2d12',
+    '#881337',
+    '#14532d',
+    '#0f172a',
+    '#312e81',
+    '#3f3f46',
+    '#422006'
+];
+let cachedChoices = null;
+function spreadsheetTableStyleChoices() {
+    cachedChoices ??= Object.freeze([
+        ...tableStyleFamilyChoices('light', 21),
+        ...tableStyleFamilyChoices('medium', 28),
+        ...tableStyleFamilyChoices('dark', 11)
+    ]);
+    return cachedChoices;
+}
+function spreadsheetTableStylePalette(style) {
+    if ('none' === style.family) return null;
+    const maximum = 'light' === style.family ? 21 : 'medium' === style.family ? 28 : 11;
+    if (!Number.isInteger(style.number) || style.number < 1 || style.number > maximum) return null;
+    if ('light' === style.family) return lightPalette(style.number);
+    if ('medium' === style.family) return mediumPalette(style.number);
+    return darkPalette(style.number);
+}
+function createSpreadsheetTableRenderResolver(tables) {
+    const renderable = tables.filter((table)=>spreadsheetTableStylePalette(table.style)).slice().sort((left, right)=>left.range.row[0] - right.range.row[0] || left.range.column[0] - right.range.column[0]);
+    let cachedRow = -1;
+    let rowTables = [];
+    return (row, column)=>{
+        if (row !== cachedRow) {
+            cachedRow = row;
+            rowTables = renderable.filter((table)=>row >= table.range.row[0] && row <= table.range.row[1]);
+        }
+        const table = rowTables.find((candidate)=>column >= candidate.range.column[0] && column <= candidate.range.column[1]);
+        return table ? spreadsheetTableCellRenderStyle(table, row, column) : null;
+    };
+}
+function spreadsheetTableCellRenderStyle(table, row, column) {
+    const palette = spreadsheetTableStylePalette(table.style);
+    if (!palette) return null;
+    const header = table.headerRow && row === table.range.row[0];
+    const totals = table.totalsRow && row === table.range.row[1];
+    const dataStart = table.range.row[0] + Number(table.headerRow);
+    const dataIndex = Math.max(0, row - dataStart);
+    const secondary = table.showRowStripes && dataIndex % 2 === 1;
+    let background = header ? palette.header : totals ? palette.total : secondary ? palette.secondaryRow : palette.primaryRow;
+    if (!header && !totals && table.showColumnStripes && (column - table.range.column[0]) % 2 === 1) background = mixHex(background, palette.stripeColumn, 0.42);
+    const firstColumn = column === table.range.column[0];
+    const lastColumn = column === table.range.column[1];
+    return {
+        background,
+        bold: header || totals || table.showFirstColumn && firstColumn || table.showLastColumn && lastColumn,
+        borderColor: palette.border,
+        role: header ? 'header' : totals ? 'totals' : 'body',
+        tableId: table.id,
+        textColor: header ? palette.headerText : totals ? palette.totalText : palette.text
+    };
+}
+function tableStyleFamilyChoices(family, count) {
+    return Array.from({
+        length: count
+    }, (_, index)=>{
+        const number = index + 1;
+        const style = {
+            family,
+            number
+        };
+        return {
+            label: `${familyLabel(family)} ${number}`,
+            ooxmlName: `TableStyle${capitalize(family)}${number}`,
+            palette: spreadsheetTableStylePalette(style),
+            style
+        };
+    });
+}
+function lightPalette(number) {
+    const accent = ACCENTS[(number - 1) % ACCENTS.length] ?? ACCENTS[0];
+    const variant = Math.floor((number - 1) / ACCENTS.length);
+    const headerWeight = [
+        0.84,
+        0.73,
+        0.62
+    ][variant] ?? 0.72;
+    return {
+        border: mixHex(accent, '#ffffff', 0.5),
+        header: mixHex(accent, '#ffffff', headerWeight),
+        headerText: mixHex(accent, '#0f172a', 0.38),
+        primaryRow: '#ffffff',
+        secondaryRow: mixHex(accent, '#ffffff', 0.9 - 0.025 * variant),
+        stripeColumn: mixHex(accent, '#ffffff', 0.82),
+        text: '#1f2937',
+        total: mixHex(accent, '#ffffff', 0.78),
+        totalText: '#172033'
+    };
+}
+function mediumPalette(number) {
+    const accent = ACCENTS[(number - 1) % ACCENTS.length] ?? ACCENTS[0];
+    const variant = Math.floor((number - 1) / ACCENTS.length);
+    const header = mixHex(accent, '#111827', 0.08 * variant);
+    return {
+        border: mixHex(accent, '#ffffff', 0.34),
+        header,
+        headerText: '#ffffff',
+        primaryRow: '#ffffff',
+        secondaryRow: mixHex(accent, '#ffffff', 0.86 - 0.02 * variant),
+        stripeColumn: mixHex(accent, '#ffffff', 0.76),
+        text: '#172033',
+        total: mixHex(accent, '#ffffff', 0.72),
+        totalText: mixHex(accent, '#111827', 0.48)
+    };
+}
+function darkPalette(number) {
+    const accent = DARK_ACCENTS[number - 1] ?? DARK_ACCENTS[0];
+    return {
+        border: mixHex(accent, '#ffffff', 0.32),
+        header: accent,
+        headerText: '#ffffff',
+        primaryRow: mixHex(accent, '#ffffff', 0.9),
+        secondaryRow: mixHex(accent, '#ffffff', 0.78),
+        stripeColumn: mixHex(accent, '#ffffff', 0.68),
+        text: '#172033',
+        total: mixHex(accent, '#ffffff', 0.62),
+        totalText: mixHex(accent, '#111827', 0.34)
+    };
+}
+function mixHex(left, right, rightWeight) {
+    const weight = Math.min(1, Math.max(0, rightWeight));
+    const leftRgb = parseHex(left);
+    const rightRgb = parseHex(right);
+    return `#${leftRgb.map((value, index)=>Math.round(value * (1 - weight) + (rightRgb[index] ?? value) * weight).toString(16).padStart(2, '0')).join('')}`;
+}
+function parseHex(value) {
+    const hex = value.replace(/^#/, '');
+    return [
+        0,
+        2,
+        4
+    ].map((offset)=>Number.parseInt(hex.slice(offset, offset + 2), 16));
+}
+function familyLabel(family) {
+    if ('light' === family) return '浅色';
+    if ('medium' === family) return '中等';
+    return '深色';
+}
+function capitalize(value) {
+    return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+const MAX_TABLE_CONVERSION_DENSE_FOOTPRINT = 1000000;
+function canMaterializeSpreadsheetTableAppearance(table) {
+    return 'none' === table.style.family || spreadsheet_cell_range_spreadsheetCellRangeArea(table.range) <= 100000;
+}
+function materializeSpreadsheetTableAppearance(content, sheetId, table) {
+    if (!canMaterializeSpreadsheetTableAppearance(table)) return null;
+    if ('none' === table.style.family) return content;
+    const sheetIndex = content.sheets.findIndex((sheet)=>sheet.id === sheetId);
+    const sheet = content.sheets[sheetIndex];
+    const palette = spreadsheetTableStylePalette(table.style);
+    if (!sheet || !palette) return null;
+    const resolve = createSpreadsheetTableRenderResolver([
+        table
+    ]);
+    const styledSheet = shouldMaterializeSpreadsheetTableAsSparseCells(sheet, table) ? materializeSpreadsheetTableSparseCells(sheet, table, resolve) : materializeSpreadsheetTableMatrix(sheet, table, resolve);
+    const sheets = [
+        ...content.sheets
+    ];
+    sheets[sheetIndex] = styledSheet;
+    return setSpreadsheetCellBorders({
+        ...content,
+        sheets
+    }, sheetId, table.range, {
+        target: 'all',
+        color: palette.border,
+        style: 'thin'
+    });
+}
+function shouldMaterializeSpreadsheetTableAsSparseCells(sheet, table) {
+    if (void 0 === sheet.data) return true;
+    const [startRow, endRow] = table.range.row;
+    const requiredRowLength = table.range.column[1] + 1;
+    let footprint = 0;
+    let presentTableRows = 0;
+    for (const [rowIndex, row] of sparseArrayEntries(sheet.data)){
+        if (rowIndex >= startRow && rowIndex <= endRow) {
+            presentTableRows += 1;
+            footprint += Math.max(row.length, requiredRowLength);
+        } else footprint += row.length;
+        if (footprint > MAX_TABLE_CONVERSION_DENSE_FOOTPRINT) return true;
+    }
+    footprint += (endRow - startRow + 1 - presentTableRows) * requiredRowLength;
+    return footprint > MAX_TABLE_CONVERSION_DENSE_FOOTPRINT;
+}
+function materializeSpreadsheetTableMatrix(sheet, table, resolve) {
+    const source = sheet.data ?? [];
+    const data = [];
+    data.length = Math.max(source.length, table.range.row[1] + 1);
+    for (const [row, value] of sparseArrayEntries(source))data[row] = value;
+    for(let row = table.range.row[0]; row <= table.range.row[1]; row += 1){
+        const sourceRow = source[row];
+        const values = [];
+        values.length = Math.max(sourceRow?.length ?? 0, table.range.column[1] + 1);
+        for (const column of sparseArrayIndexes(sourceRow))values[column] = sourceRow?.[column];
+        for(let column = table.range.column[0]; column <= table.range.column[1]; column += 1){
+            const style = resolve(row, column);
+            if (style) values[column] = spreadsheetCellWithTableAppearance(values[column], style);
+        }
+        data[row] = values;
+    }
+    return {
+        ...sheet,
+        data
+    };
+}
+function materializeSpreadsheetTableSparseCells(sheet, table, resolve) {
+    const celldata = [];
+    if (void 0 !== sheet.data) for (const [row, values] of sparseArrayEntries(sheet.data))for (const column of sparseArrayIndexes(values)){
+        const cell = values[column];
+        if (null != cell) celldata.push({
+            c: column,
+            r: row,
+            v: cell
+        });
+    }
+    else celldata.push(...sheet.celldata ?? []);
+    const indexes = new Map(celldata.map((entry, index)=>[
+            `${entry.r}:${entry.c}`,
+            index
+        ]));
+    for(let row = table.range.row[0]; row <= table.range.row[1]; row += 1)for(let column = table.range.column[0]; column <= table.range.column[1]; column += 1){
+        const style = resolve(row, column);
+        if (!style) continue;
+        const key = `${row}:${column}`;
+        const index = indexes.get(key);
+        const cell = spreadsheetCellWithTableAppearance(void 0 === index ? void 0 : celldata[index]?.v, style);
+        if (void 0 === index) {
+            indexes.set(key, celldata.length);
+            celldata.push({
+                c: column,
+                r: row,
+                v: cell
+            });
+        } else celldata[index] = {
+            c: column,
+            r: row,
+            v: cell
+        };
+    }
+    celldata.sort((left, right)=>left.r - right.r || left.c - right.c);
+    const { data: _data, ...metadata } = sheet;
+    return {
+        ...metadata,
+        celldata
+    };
+}
+function spreadsheetCellWithTableAppearance(cell, style) {
+    return {
+        ...cell ?? {},
+        bg: style.background,
+        fc: style.textColor,
+        ...style.bold ? {
+            bl: 1
+        } : {}
+    };
+}
+function createSpreadsheetTableDialogSource(content, target) {
+    const sheet = content.sheets.find((candidate)=>candidate.id === target.sheetId);
+    if (!sheet) return null;
+    const range = spreadsheetSelectionOrCurrentRegion(sheet, target.selection);
+    if (!range) return null;
+    let request = {
+        headerRow: true,
+        name: nextSpreadsheetTableName(content),
+        range,
+        sheetId: target.sheetId
+    };
+    if (!validateSpreadsheetTableRequest(content, request).ok) {
+        request = {
+            ...request,
+            headerRow: false
+        };
+        if (!validateSpreadsheetTableRequest(content, request).ok) return null;
+    }
+    const rangeReference = formatSpreadsheetCellRanges([
+        range
+    ]);
+    return {
+        name: request.name,
+        range,
+        rangeReference,
+        sheetId: target.sheetId,
+        sheetName: sheet.name,
+        value: {
+            headerRow: request.headerRow,
+            rangeReference
+        }
+    };
+}
+function spreadsheetTableRangeFromText(value) {
+    const ranges = parseSpreadsheetCellRanges(value);
+    return ranges?.length === 1 ? ranges[0] ?? null : null;
+}
+function validateSpreadsheetTableRequest(content, request) {
+    const sheet = content.sheets.find((candidate)=>candidate.id === request.sheetId);
+    if (!sheet) return tableError('sheet-not-found');
+    if (sheet.isPivotTable || sheet.pivotTables?.length) return tableError('pivot-table');
+    const range = spreadsheet_cell_range_normalizeSpreadsheetCellRange(request.range);
+    if (!range) return tableError('invalid-range');
+    const name = request.name.trim();
+    if (!validSpreadsheetTableName(name)) return tableError('invalid-name');
+    if (spreadsheetTableNameExists(content, name)) return tableError('name-conflict');
+    const bounds = spreadsheetSheetBounds(sheet);
+    if (range.row[1] > bounds.lastRow || range.column[1] > bounds.lastColumn) return tableError('out-of-bounds');
+    const height = range.row[1] - range.row[0] + 1;
+    if (height <= Number(request.headerRow)) return tableError('invalid-range');
+    if (spreadsheet_cell_range_spreadsheetCellRangeArea(range) > 100000) return tableError('range-too-large');
+    if (spreadsheetTableIntersectsMerge(sheet, range)) return tableError('merged-range');
+    if ((sheet.tables ?? []).some((table)=>spreadsheetCellRangesIntersect(table.range, range))) return tableError('table-overlap');
+    const autoFilter = spreadsheet_cell_range_normalizeSpreadsheetCellRange(sheet.filter_select ?? {
+        row: [],
+        column: []
+    });
+    if (autoFilter && spreadsheetCellRangesIntersect(autoFilter, range)) return tableError('auto-filter-overlap');
+    if (!canMutateSpreadsheetCellRanges(sheet, [
+        range
+    ])) return tableError('protected-range');
+    const style = request.style ?? {
+        family: 'medium',
+        number: 2
+    };
+    if (!validSpreadsheetTableStyle(style)) return tableError('invalid-style');
+    const columns = spreadsheetTableColumnNames(sheet, range, request.headerRow);
+    if (!columns.length || columns.some((column)=>!validTableColumnName(column))) return tableError('invalid-column-name');
+    return {
+        columns,
+        name,
+        ok: true,
+        range,
+        sheet
+    };
+}
+function applySpreadsheetTable(content, request) {
+    const validation = validateSpreadsheetTableRequest(content, request);
+    if (!validation.ok) return null;
+    const style = request.style ?? {
+        family: 'medium',
+        number: 2
+    };
+    const table = {
+        id: createWorkId('spreadsheet-table'),
+        name: validation.name,
+        range: cloneRange(validation.range),
+        columns: validation.columns.map((name)=>({
+                name
+            })),
+        filters: [],
+        headerRow: request.headerRow,
+        totalsRow: false,
+        style,
+        showFirstColumn: false,
+        showLastColumn: false,
+        showRowStripes: 'none' !== style.family,
+        showColumnStripes: false
+    };
+    const nextSheet = request.headerRow ? stampSpreadsheetTableHeaders(validation.sheet, validation.range, validation.columns) : validation.sheet;
+    return replaceSpreadsheetTableSheet(content, {
+        ...nextSheet,
+        tables: [
+            ...nextSheet.tables ?? [],
+            table
+        ]
+    });
+}
+function updateSpreadsheetTable(content, sheetId, tableId, patch) {
+    const sheet = content.sheets.find((candidate)=>candidate.id === sheetId);
+    const table = sheet?.tables?.find((candidate)=>candidate.id === tableId);
+    if (!sheet || !table) return null;
+    const name = patch.name?.trim() ?? table.name;
+    if (!validSpreadsheetTableName(name) || spreadsheetTableNameExists(content, name, tableId)) return null;
+    const style = patch.style ?? table.style;
+    if (!validSpreadsheetTableStyle(style)) return null;
+    const showFirstColumn = patch.showFirstColumn ?? table.showFirstColumn;
+    const showLastColumn = patch.showLastColumn ?? table.showLastColumn;
+    const showRowStripes = patch.showRowStripes ?? table.showRowStripes;
+    const showColumnStripes = patch.showColumnStripes ?? table.showColumnStripes;
+    if ('none' === style.family && (showFirstColumn || showLastColumn || showRowStripes || showColumnStripes)) return null;
+    const tables = sheet.tables?.map((candidate)=>candidate.id === tableId ? {
+            ...candidate,
+            name,
+            ...void 0 === patch.name ? {} : {
+                displayName: void 0
+            },
+            style,
+            showFirstColumn,
+            showLastColumn,
+            showRowStripes,
+            showColumnStripes
+        } : candidate);
+    return replaceSpreadsheetTableSheet(content, {
+        ...sheet,
+        tables
+    });
+}
+function convertSpreadsheetTableToRange(content, sheetId, tableId) {
+    const sheet = content.sheets.find((candidate)=>candidate.id === sheetId);
+    const table = sheet?.tables?.find((candidate)=>candidate.id === tableId);
+    if (!sheet || !table || spreadsheetTableHasStructuredReferences(content, table)) return null;
+    const remaining = sheet.tables?.filter((candidate)=>candidate.id !== tableId);
+    const withoutTable = replaceSpreadsheetTableSheet(content, {
+        ...sheet,
+        tables: remaining?.length ? remaining : void 0
+    });
+    return materializeSpreadsheetTableAppearance(withoutTable, sheetId, table);
+}
+function spreadsheetTableAtCell(sheet, row, column) {
+    if (!sheet) return null;
+    return (sheet.tables ?? []).find((table)=>spreadsheetCellRangeContains(table.range, row, column)) ?? null;
+}
+function spreadsheetTableFailureMessage(content, request) {
+    const validation = validateSpreadsheetTableRequest(content, request);
+    return validation.ok ? null : validation.message;
+}
+function nextSpreadsheetTableName(content) {
+    for(let index = 1; index <= 65536; index += 1){
+        const candidate = `Table${index}`;
+        if (!spreadsheetTableNameExists(content, candidate)) return candidate;
+    }
+    return 'Table65536';
+}
+function spreadsheetTableNameExists(content, name, exceptTableId) {
+    const normalized = name.toLocaleLowerCase();
+    return content.sheets.some((sheet)=>(sheet.tables ?? []).some((table)=>table.id !== exceptTableId && [
+                table.name,
+                table.displayName
+            ].some((candidate)=>candidate?.toLocaleLowerCase() === normalized))) || (content.namedRanges ?? []).some((range)=>range.name.trim().toLocaleLowerCase() === normalized);
+}
+function validSpreadsheetTableName(name) {
+    return isValidSpreadsheetDefinedName(name) && !name.startsWith('_xlnm.') && ![
+        'r',
+        'c'
+    ].includes(name.toLocaleLowerCase());
+}
+function validSpreadsheetTableStyle(style) {
+    if ('none' === style.family) return true;
+    if (!Number.isInteger(style.number)) return false;
+    if ('light' === style.family) return style.number >= 1 && style.number <= 21;
+    if ('medium' === style.family) return style.number >= 1 && style.number <= 28;
+    return style.number >= 1 && style.number <= 11;
+}
+function spreadsheetTableColumnNames(sheet, range, headerRow) {
+    const observed = new Set();
+    const names = [];
+    for(let column = range.column[0]; column <= range.column[1]; column += 1){
+        const raw = headerRow ? spreadsheet_table_spreadsheetCellText(sheet, range.row[0], column).trim() : '';
+        const base = validTableColumnName(raw) ? raw : `Column${column - range.column[0] + 1}`;
+        let candidate = base;
+        let suffix = 2;
+        while(observed.has(candidate.toLocaleLowerCase())){
+            const suffixText = String(suffix);
+            candidate = `${truncateTableColumnName(base, 255 - suffixText.length)}${suffixText}`;
+            suffix += 1;
+        }
+        observed.add(candidate.toLocaleLowerCase());
+        names.push(candidate);
+    }
+    return names;
+}
+function validTableColumnName(name) {
+    const characters = Array.from(name);
+    return name.trim() === name && characters.length >= 1 && characters.length <= 255 && !characters.some((character)=>/\p{Cc}/u.test(character) || '\uFFFE' === character || '\uFFFF' === character);
+}
+function truncateTableColumnName(value, maximum) {
+    return Array.from(value).slice(0, maximum).join('');
+}
+function spreadsheet_table_spreadsheetCellText(sheet, row, column) {
+    const cell = sheet.data?.[row]?.[column] ?? sheet.celldata?.find((candidate)=>candidate.r === row && candidate.c === column)?.v;
+    const value = cell?.m ?? cell?.v;
+    return null == value ? '' : String(value);
+}
+function stampSpreadsheetTableHeaders(sheet, range, names) {
+    if (void 0 !== sheet.data) {
+        const data = cloneSparseMatrixShell(sheet.data);
+        const sourceRow = sheet.data[range.row[0]];
+        const row = cloneSparseRow(sourceRow);
+        for (const [offset, name] of names.entries()){
+            const column = range.column[0] + offset;
+            row[column] = stampHeaderCell(sourceRow?.[column], name);
+        }
+        data[range.row[0]] = row;
+        return {
+            ...sheet,
+            data
+        };
+    }
+    const byCoordinate = new Map((sheet.celldata ?? []).map((entry)=>[
+            `${entry.r}_${entry.c}`,
+            entry
+        ]));
+    for (const [offset, name] of names.entries()){
+        const column = range.column[0] + offset;
+        const key = `${range.row[0]}_${column}`;
+        const source = byCoordinate.get(key);
+        byCoordinate.set(key, {
+            r: range.row[0],
+            c: column,
+            v: stampHeaderCell(source?.v, name)
+        });
+    }
+    return {
+        ...sheet,
+        celldata: [
+            ...byCoordinate.values()
+        ]
+    };
+}
+function cloneSparseMatrixShell(source) {
+    const data = [];
+    data.length = source.length;
+    for (const [row, value] of sparseArrayEntries(source))data[row] = value;
+    return data;
+}
+function cloneSparseRow(source) {
+    const row = [];
+    if (!source) return row;
+    row.length = source.length;
+    for (const column of sparseArrayIndexes(source))row[column] = source[column];
+    return row;
+}
+function stampHeaderCell(source, name) {
+    return {
+        ...source ?? {},
+        m: name,
+        v: name
+    };
+}
+function spreadsheetTableIntersectsMerge(sheet, range) {
+    return Object.values(sheet.config?.merge ?? {}).some((merge)=>spreadsheetCellRangesIntersect(range, {
+            row: [
+                merge.r,
+                merge.r + Math.max(1, merge.rs) - 1
+            ],
+            column: [
+                merge.c,
+                merge.c + Math.max(1, merge.cs) - 1
+            ]
+        }));
+}
+function replaceSpreadsheetTableSheet(content, nextSheet) {
+    return {
+        ...content,
+        sheets: content.sheets.map((sheet)=>sheet.id === nextSheet.id ? nextSheet : sheet)
+    };
+}
+function spreadsheetTableHasStructuredReferences(content, table) {
+    const aliases = [
+        table.name,
+        table.displayName
+    ].filter((value)=>Boolean(value));
+    const patterns = aliases.map((alias)=>new RegExp(`${escapeRegExp(alias)}\\s*\\[`, 'i'));
+    const matches = (value)=>'string' == typeof value && patterns.some((pattern)=>pattern.test(value));
+    for (const sheet of content.sheets){
+        for (const [, row] of sparseArrayEntries(sheet.data))for (const [, cell] of sparseArrayEntries(row))if (matches(cell?.f)) return true;
+        for (const entry of sheet.celldata ?? [])if (matches(entry.v?.f)) return true;
+        if (Object.values(sheet.formulaMetadata?.sourceFormulas ?? {}).some(matches) || matches(JSON.stringify(sheet.dataValidationRanges ?? [])) || matches(JSON.stringify(sheet.luckysheet_conditionformat_save ?? [])) || matches(JSON.stringify(sheet.charts ?? []))) return true;
+    }
+    return (content.namedRanges ?? []).some((range)=>matches(range.reference));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function cloneRange(range) {
+    return {
+        row: [
+            ...range.row
+        ],
+        column: [
+            ...range.column
+        ]
+    };
+}
+function tableError(code) {
+    const messages = {
+        'auto-filter-overlap': '表格区域不能与工作表自动筛选区域重叠。',
+        'invalid-column-name': '表格列名必须唯一且不超过 255 个字符。',
+        'invalid-name': '表格名称必须是有效且不类似单元格引用的标识符。',
+        'invalid-range': '表格至少需要一行数据。',
+        'invalid-style': '表格样式身份无效。',
+        'merged-range': '请先取消表格区域内的合并单元格。',
+        'name-conflict': '表格名称已被其他表格或名称使用。',
+        'out-of-bounds': '表格区域超出当前工作表边界。',
+        'pivot-table': '数据透视表工作表不能创建普通表格。',
+        'protected-range': '受保护或只读区域不能创建表格。',
+        'range-too-large': `一次最多可创建 ${100000..toLocaleString()} 个单元格的表格。`,
+        'sheet-not-found': '找不到目标工作表。',
+        'table-overlap': '表格区域不能与其他表格重叠。'
+    };
+    return {
+        code,
+        message: messages[code],
+        ok: false
+    };
+}
+function createSpreadsheetTableExtension() {
+    return createOfficeEditorExtension({
+        name: 'spreadsheetTables',
+        addCommands: ()=>({
+                openTable: {
+                    canExecute: canOpenSpreadsheetTable,
+                    execute: openSpreadsheetTable
+                },
+                applyTable: {
+                    canExecute: (context, request)=>context.editable && validateSpreadsheetTableRequest(context.content, request).ok,
+                    execute: applySpreadsheetTableCommand
+                },
+                updateTable: {
+                    canExecute: canUpdateSpreadsheetTable,
+                    execute: updateSpreadsheetTableCommand
+                },
+                convertTableToRange: {
+                    canExecute: canConvertSpreadsheetTableToRange,
+                    execute: convertSpreadsheetTableToRangeCommand
+                }
+            }),
+        addKeyboardShortcuts: ()=>({
+                [spreadsheetCommandCatalog.table.shortcut.editor["0"]]: ({ can, commands }, event)=>runSpreadsheetTableShortcut(event, can.openTable, commands.openTable)
+            })
+    });
+}
+function canOpenSpreadsheetTable(context) {
+    const target = liveSpreadsheetTableTarget(context);
+    const sheet = context.content.sheets.find((candidate)=>candidate.id === target?.sheetId);
+    const focus = target?.selection;
+    const row = focus?.row_focus ?? focus?.row[0] ?? 0;
+    const column = focus?.column_focus ?? focus?.column[0] ?? 0;
+    return Boolean(context.editable && context.table.canOpen && context.workbook && target && target.sheetId === context.activeSheetId && sheet && !sheet.isPivotTable && !sheet.pivotTables?.length && !spreadsheetTableAtCell(sheet, row, column));
+}
+function openSpreadsheetTable(context) {
+    const target = liveSpreadsheetTableTarget(context);
+    return Boolean(target && canOpenSpreadsheetTable(context) && context.table.open(target));
+}
+function applySpreadsheetTableCommand(context, request) {
+    if (!context.editable) return false;
+    const next = applySpreadsheetTable(context.content, request);
+    if (!next) return false;
+    context.onChange(next);
+    return true;
+}
+function canUpdateSpreadsheetTable(context, sheetId, tableId, patch) {
+    return Boolean(context.editable && updateSpreadsheetTable(context.content, sheetId, tableId, patch));
+}
+function updateSpreadsheetTableCommand(context, sheetId, tableId, patch) {
+    if (!context.editable) return false;
+    const next = updateSpreadsheetTable(context.content, sheetId, tableId, patch);
+    if (!next) return false;
+    context.onChange(next);
+    return true;
+}
+function canConvertSpreadsheetTableToRange(context, sheetId, tableId) {
+    return Boolean(context.editable && context.content.sheets.find((sheet)=>sheet.id === sheetId)?.tables?.some((table)=>table.id === tableId && canMaterializeSpreadsheetTableAppearance(table)));
+}
+function convertSpreadsheetTableToRangeCommand(context, sheetId, tableId) {
+    if (!context.editable) return false;
+    const next = convertSpreadsheetTableToRange(context.content, sheetId, tableId);
+    if (!next) return false;
+    context.onChange(next);
+    return true;
+}
+function liveSpreadsheetTableTarget(context) {
+    if (!context.workbook || !context.targetSheetId) return null;
+    const selection = context.workbook.getSelection()?.at(-1) ?? context.fallbackRange;
+    return {
+        sheetId: context.targetSheetId,
+        selection: finiteSpreadsheetSelection(selection)
+    };
+}
+function runSpreadsheetTableShortcut(event, canExecute, execute) {
+    if (event.repeat || event.isComposing || isOfficeShortcutBlocked(event.target) || isSpreadsheetNativeTextUndoTarget(event.target) || !isSpreadsheetGridKeyboardTarget(event.target)) return false;
+    if (!event.repeat && canExecute()) execute();
+    return true;
+}
+function createSpreadsheetEditorExtensions() {
+    return [
+        createOfficeEditorExtension({
+            name: 'spreadsheetDocument',
+            addCommands: ()=>({
+                    setSpreadsheetContent: {
+                        canExecute: (context)=>context.editable,
+                        execute: (context, content)=>{
+                            if (!context.editable) return false;
+                            context.onChange(content);
+                            return true;
+                        }
+                    }
+                })
+        }),
+        createSpreadsheetCellFormatExtension(),
+        createSpreadsheetCellBorderExtension(),
+        createSpreadsheetCellStyleExtension(),
+        createSpreadsheetNumberFormatExtension(),
+        createSpreadsheetNavigationExtension(),
+        createSpreadsheetDataValidationExtension(),
+        createSpreadsheetHyperlinkExtension(),
+        createSpreadsheetTableExtension(),
+        createSpreadsheetAutoSumExtension(),
+        createSpreadsheetCellFillExtension(),
+        createOfficeEditorExtension({
+            name: 'spreadsheetFormatPainter',
+            addCommands: ()=>({
+                    activateFormatPainter: {
+                        canExecute: ({ formatPainter })=>formatPainter.canActivate,
+                        execute: ({ formatPainter }, mode)=>formatPainter.canActivate && formatPainter.activate(mode)
+                    },
+                    applyFormatPainter: {
+                        canExecute: ({ formatPainter })=>formatPainter.active,
+                        execute: ({ formatPainter }, target)=>formatPainter.active && formatPainter.applySelection(target)
+                    },
+                    cancelFormatPainter: {
+                        canExecute: ({ formatPainter })=>formatPainter.active,
+                        execute: ({ formatPainter })=>formatPainter.active && formatPainter.cancel()
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'spreadsheetAutoFilter',
+            addCommands: ()=>({
+                    openAutoFilterMenu: {
+                        canExecute: ({ autoFilter })=>autoFilter.canOpenMenu,
+                        execute: ({ autoFilter })=>autoFilter.canOpenMenu && autoFilter.openMenu()
+                    },
+                    toggleAutoFilter: {
+                        canExecute: ({ autoFilter })=>autoFilter.canToggle,
+                        execute: ({ autoFilter })=>autoFilter.canToggle && autoFilter.toggle()
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'spreadsheetClipboard',
+            addCommands: ()=>({
+                    copySelection: {
+                        canExecute: ({ clipboard })=>clipboard.canCopySelection,
+                        execute: ({ clipboard })=>clipboard.canCopySelection && clipboard.copySelection()
+                    },
+                    cutSelection: {
+                        canExecute: ({ clipboard })=>clipboard.canCutSelection,
+                        execute: ({ clipboard })=>clipboard.canCutSelection && clipboard.cutSelection()
+                    },
+                    pasteSelection: {
+                        canExecute: ({ clipboard })=>clipboard.canPasteSelection,
+                        execute: ({ clipboard })=>clipboard.canPasteSelection && clipboard.pasteSelection()
+                    },
+                    pasteSpecial: {
+                        canExecute: ({ clipboard }, content)=>clipboard.canPasteSpecial(content),
+                        execute: ({ clipboard }, content)=>clipboard.canPasteSpecial(content) && clipboard.pasteSpecial(content)
+                    },
+                    openPasteSpecial: {
+                        canExecute: ({ clipboard })=>clipboard.canOpenPasteSpecial,
+                        execute: ({ clipboard })=>clipboard.canOpenPasteSpecial && clipboard.openPasteSpecial()
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'spreadsheetHistory',
+            addCommands: ()=>({
+                    redo: {
+                        canExecute: (context)=>context.editable && (context.history?.canRedo ?? false),
+                        execute: (context)=>context.history?.redo() ?? false
+                    },
+                    undo: {
+                        canExecute: (context)=>context.editable && (context.history?.canUndo ?? false),
+                        execute: (context)=>context.history?.undo() ?? false
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'spreadsheetSheets',
+            addCommands: ()=>({
+                    activateSheet: {
+                        canExecute: (context, sheetId)=>{
+                            const sheet = context.content.sheets.find((candidate)=>candidate.id === sheetId);
+                            return Boolean(sheet && (context.editable || context.view && 1 !== sheet.hide));
+                        },
+                        execute: (context, sheetId)=>{
+                            const sheet = context.content.sheets.find((candidate)=>candidate.id === sheetId);
+                            if (!sheet) return false;
+                            if (context.view && 1 !== sheet.hide) return context.view?.activateSheet(sheetId) ?? false;
+                            if (!context.editable) return false;
+                            return applySpreadsheetSheetChange(context, activateSpreadsheetSheet(context.content, sheetId));
+                        }
+                    },
+                    addSheet: {
+                        canExecute: (context)=>context.editable,
+                        execute: (context)=>applySpreadsheetSheetChange(context, addSpreadsheetSheet(context.content))
+                    },
+                    deleteSheet: {
+                        canExecute: (context, sheetId)=>Boolean(context.editable && context.content.sheets.length > 1 && context.content.sheets.some((sheet)=>sheet.id === sheetId)),
+                        execute: (context, sheetId)=>applySpreadsheetSheetChange(context, deleteSpreadsheetSheet(context.content, sheetId))
+                    },
+                    duplicateSheet: {
+                        canExecute: (context, sheetId)=>context.editable && context.content.sheets.some((sheet)=>sheet.id === sheetId),
+                        execute: (context, sheetId)=>applySpreadsheetSheetChange(context, duplicateSpreadsheetSheet(context.content, sheetId))
+                    },
+                    hideSheet: {
+                        canExecute: (context, sheetId)=>context.editable && context.content.sheets.filter((sheet)=>1 !== sheet.hide).length > 1 && context.content.sheets.some((sheet)=>sheet.id === sheetId && 1 !== sheet.hide),
+                        execute: (context, sheetId)=>applySpreadsheetSheetChange(context, hideSpreadsheetSheet(context.content, sheetId, true))
+                    },
+                    moveSheet: {
+                        canExecute: (context, sheetId, direction)=>Boolean(context.editable && moveSpreadsheetSheet(context.content, sheetId, direction)),
+                        execute: (context, sheetId, direction)=>applySpreadsheetSheetChange(context, moveSpreadsheetSheet(context.content, sheetId, direction))
+                    },
+                    renameSheet: {
+                        canExecute: (context, sheetId, name)=>Boolean(context.editable && renameSpreadsheetSheet(context.content, sheetId, name)),
+                        execute: (context, sheetId, name)=>applySpreadsheetSheetChange(context, renameSpreadsheetSheet(context.content, sheetId, name))
+                    },
+                    setSheetColor: {
+                        canExecute: (context, sheetId, color)=>Boolean(context.editable && setSpreadsheetSheetColor(context.content, sheetId, color)),
+                        execute: (context, sheetId, color)=>applySpreadsheetSheetChange(context, setSpreadsheetSheetColor(context.content, sheetId, color))
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'spreadsheetKeyboardShortcuts',
+            addKeyboardShortcuts: ()=>({
                     'Mod-a': ({ can, commands }, event)=>selectSpreadsheetFormulaBarContents(event) || runSpreadsheetSelectionScopeShortcut(event, can.selectCellRange, commands.selectCellRange, 'all'),
                     'Mod-b': ({ can, commands, context }, event)=>runSpreadsheetCellFormatShortcut(event, context, can.setCellFormat, commands.setCellFormat, 'bl'),
                     'Mod-c': ({ can, commands }, event)=>runSpreadsheetClipboardShortcut(event, can.copySelection, commands.copySelection),
@@ -6283,9 +7545,16 @@ function canInsertSelectedStructure(context, axis, _position) {
     const [start, end] = spreadsheetStructureRange(range, axis);
     const count = end - start + 1;
     const maximum = 'row' === axis ? 10000 : 1000;
-    return spreadsheetStructureExtent(context, axis) + count < maximum;
+    return spreadsheetStructureExtent(context, axis) + count < maximum && canApplySpreadsheetTableStructureChange(context.content.sheets.find((sheet)=>sheet.id === context.targetSheetId), {
+        axis,
+        count,
+        direction: 'before' === _position ? 'lefttop' : 'rightbottom',
+        index: 'before' === _position ? start : end,
+        kind: 'insert'
+    });
 }
 function insertSelectedStructure(context, axis, position) {
+    if (!canInsertSelectedStructure(context, axis, position)) return false;
     if (!context.workbook || !context.targetSheetId) return false;
     const [start, end] = spreadsheetStructureRange(liveRange(context), axis);
     const before = 'before' === position;
@@ -6301,9 +7570,15 @@ function insertSelectedStructure(context, axis, position) {
 function canDeleteSelectedStructure(context, axis) {
     if (!canEditSelectedCells(context)) return false;
     const [start, end] = spreadsheetStructureRange(liveRange(context), axis);
-    return end - start + 1 < spreadsheetStructureExtent(context, axis);
+    return end - start + 1 < spreadsheetStructureExtent(context, axis) && canApplySpreadsheetTableStructureChange(context.content.sheets.find((sheet)=>sheet.id === context.targetSheetId), {
+        axis,
+        end,
+        kind: 'delete',
+        start
+    });
 }
 function deleteSelectedStructure(context, axis) {
+    if (!canDeleteSelectedStructure(context, axis)) return false;
     if (!context.workbook || !context.targetSheetId) return false;
     const range = liveRange(context);
     const [start, end] = spreadsheetStructureRange(range, axis);
@@ -8654,89 +9929,350 @@ function SpreadsheetPrintSettingsPanel({ content, onChange }) {
             /*#__PURE__*/ jsxs("div", {
                 className: "actions",
                 children: [
-                    error && /*#__PURE__*/ jsx(InlineNotice, {
-                        className: "work-office-form-error",
-                        tone: "danger",
-                        role: "alert",
-                        children: error
-                    }),
-                    /*#__PURE__*/ jsx(button_Button, {
-                        tone: "secondary",
-                        disabled: dirty || !savedArea && !savedTitles && !savedPageBreaks && !savedPageSetup,
-                        onClick: clearSettings,
-                        children: "清除"
-                    }),
-                    /*#__PURE__*/ jsx(button_Button, {
-                        tone: "secondary",
-                        disabled: !dirty,
-                        onClick: cancelDraft,
-                        children: "取消更改"
+                    error && /*#__PURE__*/ jsx(InlineNotice, {
+                        className: "work-office-form-error",
+                        tone: "danger",
+                        role: "alert",
+                        children: error
+                    }),
+                    /*#__PURE__*/ jsx(button_Button, {
+                        tone: "secondary",
+                        disabled: dirty || !savedArea && !savedTitles && !savedPageBreaks && !savedPageSetup,
+                        onClick: clearSettings,
+                        children: "清除"
+                    }),
+                    /*#__PURE__*/ jsx(button_Button, {
+                        tone: "secondary",
+                        disabled: !dirty,
+                        onClick: cancelDraft,
+                        children: "取消更改"
+                    }),
+                    /*#__PURE__*/ jsx(button_Button, {
+                        type: "submit",
+                        tone: "primary",
+                        disabled: !sheetId || !dirty,
+                        children: "保存打印设置"
+                    })
+                ]
+            })
+        ]
+    });
+}
+function spreadsheetPrintSettingsDraft(content, sheetId, empty = false) {
+    const area = empty ? void 0 : content.printAreas?.find((item)=>item.sheetId === sheetId);
+    const titles = empty ? void 0 : content.printTitles?.find((item)=>item.sheetId === sheetId);
+    const pageBreaks = empty ? void 0 : content.pageBreaks?.find((item)=>item.sheetId === sheetId);
+    const pageSetup = empty ? void 0 : content.pageSetups?.find((item)=>item.sheetId === sheetId);
+    return {
+        reference: area?.reference ?? '',
+        titleRows: titles?.rows ?? '',
+        titleColumns: titles?.columns ?? '',
+        rowPageBreaks: formatSpreadsheetRowPageBreaks(pageBreaks?.rows),
+        columnPageBreaks: formatSpreadsheetColumnPageBreaks(pageBreaks?.columns),
+        pageSetup: effectiveSpreadsheetPageSetup(pageSetup)
+    };
+}
+function spreadsheetMaximumRow(sheet) {
+    return Math.max(0, (sheet?.row ?? 1) - 1, (sheet?.data?.length ?? 1) - 1);
+}
+function spreadsheetMaximumColumn(sheet) {
+    let maximum = Math.max(0, (sheet?.column ?? 1) - 1);
+    for (const row of sheet?.data ?? [])maximum = Math.max(maximum, row.length - 1);
+    return maximum;
+}
+function PageMarginField({ label, value, onChange }) {
+    return /*#__PURE__*/ jsxs("div", {
+        className: "work-office-field",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                children: label
+            }),
+            /*#__PURE__*/ jsx(CommittedOfficeNumberField, {
+                ariaLabel: label,
+                min: 0,
+                max: 100,
+                step: 0.01,
+                value: value,
+                normalizeValue: (nextValue)=>normalizePrintDecimal(nextValue, 0, 100),
+                onValueCommit: onChange
+            })
+        ]
+    });
+}
+function normalizePrintInteger(value, minimum, maximum) {
+    if (!value.trim()) return null;
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.round(number))) : null;
+}
+function normalizePrintDecimal(value, minimum, maximum) {
+    if (!value.trim()) return null;
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.round(100 * number) / 100)) : null;
+}
+function validPageSetup(pageSetup) {
+    const validInteger = (value, minimum, maximum)=>Number.isInteger(value) && value >= minimum && value <= maximum;
+    return validInteger(pageSetup.scale, 10, 400) && validInteger(pageSetup.fitToWidth, 0, 32767) && validInteger(pageSetup.fitToHeight, 0, 32767) && validInteger(pageSetup.pageNumberStart, 1, 32767) && Object.values(pageSetup.margins).every((margin)=>Number.isFinite(margin) && margin >= 0 && margin <= 100);
+}
+function SpreadsheetTableDesignRibbon({ can, commands, sheetId, table }) {
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                label: "属性",
+                priority: "high",
+                children: [
+                    /*#__PURE__*/ jsx(SpreadsheetTableNameControl, {
+                        can: can,
+                        commands: commands,
+                        sheetId: sheetId,
+                        table: table
+                    }),
+                    /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
+                        label: "转换为区域",
+                        disabled: !can.convertTableToRange(sheetId, table.id),
+                        onClick: ()=>{
+                            if (!commands.convertTableToRange(sheetId, table.id)) showToast('无法转换为区域。请先移除引用此表格的结构化引用。', 'error');
+                        },
+                        children: /*#__PURE__*/ jsx(TableProperties, {
+                            size: 19
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(WorkOfficeRibbonGroup, {
+                label: "表格样式",
+                priority: "high",
+                children: /*#__PURE__*/ jsx(SpreadsheetTableStyleGallery, {
+                    commands: commands,
+                    sheetId: sheetId,
+                    table: table
+                })
+            }),
+            /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                label: "表格样式选项",
+                children: [
+                    /*#__PURE__*/ jsx(SpreadsheetTableOption, {
+                        label: "首列",
+                        active: table.showFirstColumn,
+                        icon: /*#__PURE__*/ jsx(Columns3, {
+                            size: 17
+                        }),
+                        disabled: !can.updateTable(sheetId, table.id, {
+                            showFirstColumn: !table.showFirstColumn
+                        }),
+                        onToggle: ()=>commands.updateTable(sheetId, table.id, {
+                                showFirstColumn: !table.showFirstColumn
+                            })
+                    }),
+                    /*#__PURE__*/ jsx(SpreadsheetTableOption, {
+                        label: "末列",
+                        active: table.showLastColumn,
+                        icon: /*#__PURE__*/ jsx(Columns3, {
+                            size: 17
+                        }),
+                        disabled: !can.updateTable(sheetId, table.id, {
+                            showLastColumn: !table.showLastColumn
+                        }),
+                        onToggle: ()=>commands.updateTable(sheetId, table.id, {
+                                showLastColumn: !table.showLastColumn
+                            })
+                    }),
+                    /*#__PURE__*/ jsx(SpreadsheetTableOption, {
+                        label: "行条纹",
+                        active: table.showRowStripes,
+                        icon: /*#__PURE__*/ jsx(Rows3, {
+                            size: 17
+                        }),
+                        disabled: !can.updateTable(sheetId, table.id, {
+                            showRowStripes: !table.showRowStripes
+                        }),
+                        onToggle: ()=>commands.updateTable(sheetId, table.id, {
+                                showRowStripes: !table.showRowStripes
+                            })
+                    }),
+                    /*#__PURE__*/ jsx(SpreadsheetTableOption, {
+                        label: "列条纹",
+                        active: table.showColumnStripes,
+                        icon: /*#__PURE__*/ jsx(Columns3, {
+                            size: 17
+                        }),
+                        disabled: !can.updateTable(sheetId, table.id, {
+                            showColumnStripes: !table.showColumnStripes
+                        }),
+                        onToggle: ()=>commands.updateTable(sheetId, table.id, {
+                                showColumnStripes: !table.showColumnStripes
+                            })
+                    })
+                ]
+            })
+        ]
+    });
+}
+function SpreadsheetTableNameControl({ can, commands, sheetId, table }) {
+    const [name, setName] = useState(table.name);
+    useEffect(()=>setName(table.name), [
+        table.id,
+        table.name
+    ]);
+    const commit = ()=>{
+        const candidate = name.trim();
+        if (!candidate || candidate === table.name) return void setName(table.name);
+        const patch = {
+            name: candidate
+        };
+        if (!can.updateTable(sheetId, table.id, patch) || !commands.updateTable(sheetId, table.id, patch)) {
+            setName(table.name);
+            showToast('表格名称无效或已被使用。', 'error');
+        }
+    };
+    return /*#__PURE__*/ jsxs("label", {
+        className: "work-spreadsheet-table-name",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                children: "表格名称"
+            }),
+            /*#__PURE__*/ jsx("input", {
+                type: "text",
+                "aria-label": "表格名称",
+                autoCapitalize: "none",
+                spellCheck: false,
+                value: name,
+                onBlur: commit,
+                onChange: (event)=>setName(event.currentTarget.value),
+                onKeyDown: (event)=>{
+                    if ('Enter' === event.key) {
+                        event.preventDefault();
+                        commit();
+                    } else if ('Escape' === event.key) {
+                        event.preventDefault();
+                        setName(table.name);
+                    }
+                }
+            })
+        ]
+    });
+}
+function SpreadsheetTableStyleGallery({ commands, sheetId, table }) {
+    const choices = spreadsheetTableStyleChoices();
+    const selected = choices.find((choice)=>spreadsheetTableUsesStyle(table.style, choice.style));
+    const families = [
+        {
+            id: 'light',
+            label: '浅色'
+        },
+        {
+            id: 'medium',
+            label: '中等'
+        },
+        {
+            id: 'dark',
+            label: '深色'
+        }
+    ];
+    return /*#__PURE__*/ jsx(Popover, {
+        label: "表格样式",
+        panelLabel: "表格样式库",
+        panelRole: "menu",
+        portal: true,
+        className: "work-spreadsheet-table-style-root",
+        panelClassName: "work-spreadsheet-table-style-menu",
+        focusFirstOnOpen: true,
+        onPanelKeyDown: moveSpreadsheetTableStyleFocus,
+        trigger: (triggerProps, { open })=>/*#__PURE__*/ jsxs("button", {
+                ...triggerProps,
+                type: "button",
+                className: `with-label work-spreadsheet-table-style-trigger${open ? ' active' : ''}`,
+                title: `表格样式（当前：${selected?.label ?? '无'}）`,
+                children: [
+                    /*#__PURE__*/ jsx(SpreadsheetTableStylePreview, {
+                        choice: selected ?? choices[0]
                     }),
-                    /*#__PURE__*/ jsx(button_Button, {
-                        type: "submit",
-                        tone: "primary",
-                        disabled: !sheetId || !dirty,
-                        children: "保存打印设置"
+                    /*#__PURE__*/ jsx("span", {
+                        children: "表格样式"
                     })
                 ]
+            }),
+        children: (close)=>/*#__PURE__*/ jsx(Fragment, {
+                children: families.map((family)=>/*#__PURE__*/ jsxs("fieldset", {
+                        className: "work-spreadsheet-table-style-family",
+                        "data-office-menu-grid": true,
+                        "aria-label": family.label,
+                        children: [
+                            /*#__PURE__*/ jsx("span", {
+                                children: family.label
+                            }),
+                            /*#__PURE__*/ jsx("div", {
+                                children: choices.filter((choice)=>choice.style.family === family.id).map((choice)=>{
+                                    const checked = spreadsheetTableUsesStyle(table.style, choice.style);
+                                    return /*#__PURE__*/ jsx("button", {
+                                        type: "button",
+                                        role: "menuitemradio",
+                                        tabIndex: -1,
+                                        "aria-label": `应用表格样式：${choice.label}`,
+                                        "aria-checked": checked,
+                                        title: choice.label,
+                                        onClick: ()=>{
+                                            close();
+                                            commands.updateTable(sheetId, table.id, {
+                                                style: choice.style
+                                            });
+                                        },
+                                        children: /*#__PURE__*/ jsx(SpreadsheetTableStylePreview, {
+                                            choice: choice
+                                        })
+                                    }, choice.ooxmlName);
+                                })
+                            })
+                        ]
+                    }, family.id))
             })
-        ]
     });
 }
-function spreadsheetPrintSettingsDraft(content, sheetId, empty = false) {
-    const area = empty ? void 0 : content.printAreas?.find((item)=>item.sheetId === sheetId);
-    const titles = empty ? void 0 : content.printTitles?.find((item)=>item.sheetId === sheetId);
-    const pageBreaks = empty ? void 0 : content.pageBreaks?.find((item)=>item.sheetId === sheetId);
-    const pageSetup = empty ? void 0 : content.pageSetups?.find((item)=>item.sheetId === sheetId);
-    return {
-        reference: area?.reference ?? '',
-        titleRows: titles?.rows ?? '',
-        titleColumns: titles?.columns ?? '',
-        rowPageBreaks: formatSpreadsheetRowPageBreaks(pageBreaks?.rows),
-        columnPageBreaks: formatSpreadsheetColumnPageBreaks(pageBreaks?.columns),
-        pageSetup: effectiveSpreadsheetPageSetup(pageSetup)
-    };
-}
-function spreadsheetMaximumRow(sheet) {
-    return Math.max(0, (sheet?.row ?? 1) - 1, (sheet?.data?.length ?? 1) - 1);
-}
-function spreadsheetMaximumColumn(sheet) {
-    let maximum = Math.max(0, (sheet?.column ?? 1) - 1);
-    for (const row of sheet?.data ?? [])maximum = Math.max(maximum, row.length - 1);
-    return maximum;
-}
-function PageMarginField({ label, value, onChange }) {
-    return /*#__PURE__*/ jsxs("div", {
-        className: "work-office-field",
+function moveSpreadsheetTableStyleFocus(event) {
+    const active = document.activeElement;
+    const group = [
+        ...event.currentTarget.querySelectorAll('[data-office-menu-grid]')
+    ].find((candidate)=>candidate.contains(active));
+    const grid = group?.querySelector(':scope > div');
+    const template = grid ? getComputedStyle(grid).gridTemplateColumns : '';
+    const repeated = template.match(/^repeat\(\s*(\d+)/)?.[1];
+    const resolved = template.split(/\s+/).filter((value)=>value && 'none' !== value).length;
+    const columns = repeated ? Number(repeated) : resolved || 7;
+    return moveOfficeGridMenuFocus(event, Math.max(1, columns));
+}
+function spreadsheetTableUsesStyle(tableStyle, choice) {
+    return 'none' !== tableStyle.family && tableStyle.family === choice.family && tableStyle.number === choice.number;
+}
+function SpreadsheetTableStylePreview({ choice }) {
+    return /*#__PURE__*/ jsxs("span", {
+        className: "work-spreadsheet-table-style-preview",
+        "aria-hidden": "true",
         children: [
-            /*#__PURE__*/ jsx("span", {
-                children: label
+            /*#__PURE__*/ jsx("i", {
+                style: {
+                    backgroundColor: choice.palette.header
+                }
             }),
-            /*#__PURE__*/ jsx(CommittedOfficeNumberField, {
-                ariaLabel: label,
-                min: 0,
-                max: 100,
-                step: 0.01,
-                value: value,
-                normalizeValue: (nextValue)=>normalizePrintDecimal(nextValue, 0, 100),
-                onValueCommit: onChange
+            /*#__PURE__*/ jsx("i", {
+                style: {
+                    backgroundColor: choice.palette.primaryRow
+                }
+            }),
+            /*#__PURE__*/ jsx("i", {
+                style: {
+                    backgroundColor: choice.palette.secondaryRow
+                }
             })
         ]
     });
 }
-function normalizePrintInteger(value, minimum, maximum) {
-    if (!value.trim()) return null;
-    const number = Number(value);
-    return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.round(number))) : null;
-}
-function normalizePrintDecimal(value, minimum, maximum) {
-    if (!value.trim()) return null;
-    const number = Number(value);
-    return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.round(100 * number) / 100)) : null;
-}
-function validPageSetup(pageSetup) {
-    const validInteger = (value, minimum, maximum)=>Number.isInteger(value) && value >= minimum && value <= maximum;
-    return validInteger(pageSetup.scale, 10, 400) && validInteger(pageSetup.fitToWidth, 0, 32767) && validInteger(pageSetup.fitToHeight, 0, 32767) && validInteger(pageSetup.pageNumberStart, 1, 32767) && Object.values(pageSetup.margins).every((margin)=>Number.isFinite(margin) && margin >= 0 && margin <= 100);
+function SpreadsheetTableOption({ active, disabled, icon, label, onToggle }) {
+    return /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
+        label: label,
+        active: active,
+        disabled: disabled,
+        onClick: onToggle,
+        children: icon
+    });
 }
 const defaultSpreadsheetFreezePanesSelection = {
     row: [
@@ -8750,7 +10286,11 @@ const defaultSpreadsheetFreezePanesSelection = {
     row_focus: 0,
     column_focus: 0
 };
-function SpreadsheetEditorRibbon({ activeTab, autoFilterActive = false, can, commands, content, fileActions, findOpen, formatPainterMode = null, freezePanesActive = false, freezePanesSelection = defaultSpreadsheetFreezePanesSelection, gridLinesVisible, panelId, onTabChange, onTogglePanel, panel, toolbarCell, toolbarCellBorders }) {
+function SpreadsheetEditorRibbon({ activeTab, activeTable = null, activeTableSheetId, autoFilterActive = false, can, commands, content, fileActions, findOpen, formatPainterMode = null, freezePanesActive = false, freezePanesSelection = defaultSpreadsheetFreezePanesSelection, gridLinesVisible, panelId, onTabChange, onTogglePanel, panel, toolbarCell, toolbarCellBorders }) {
+    const ribbonTabs = activeTable ? [
+        ...spreadsheetRibbonTabs,
+        spreadsheetTableDesignRibbonTab
+    ] : spreadsheetRibbonTabs;
     const formulaCount = useMemo(()=>spreadsheetFormulaCount(content), [
         content
     ]);
@@ -8759,7 +10299,7 @@ function SpreadsheetEditorRibbon({ activeTab, autoFilterActive = false, can, com
     ]);
     return /*#__PURE__*/ jsx(WorkOfficeRibbon, {
         ariaLabel: "表格功能区",
-        tabs: spreadsheetRibbonTabs,
+        tabs: ribbonTabs,
         defaultTab: "home",
         activeTab: activeTab,
         onTabChange: onTabChange,
@@ -8991,6 +10531,20 @@ function SpreadsheetEditorRibbon({ activeTab, autoFilterActive = false, can, com
             }),
             insert: /*#__PURE__*/ jsxs(Fragment, {
                 children: [
+                    /*#__PURE__*/ jsx(WorkOfficeRibbonGroup, {
+                        label: "表格",
+                        priority: "high",
+                        children: /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
+                            label: spreadsheetCommandCatalog.table.label,
+                            title: `${spreadsheetCommandCatalog.table.label}（${spreadsheetCommandCatalog.table.shortcut.label}）`,
+                            "aria-keyshortcuts": spreadsheetCommandCatalog.table.shortcut.aria,
+                            disabled: !can.openTable(),
+                            onClick: commands.openTable,
+                            children: /*#__PURE__*/ jsx(Table2, {
+                                size: 19
+                            })
+                        })
+                    }),
                     /*#__PURE__*/ jsx(WorkOfficeRibbonGroup, {
                         label: "链接",
                         priority: "high",
@@ -9188,7 +10742,13 @@ function SpreadsheetEditorRibbon({ activeTab, autoFilterActive = false, can, com
                         })
                     })
                 ]
-            })
+            }),
+            tableDesign: activeTable && activeTableSheetId ? /*#__PURE__*/ jsx(SpreadsheetTableDesignRibbon, {
+                can: can,
+                commands: commands,
+                sheetId: activeTableSheetId,
+                table: activeTable
+            }) : null
         }
     });
 }
@@ -12086,6 +13646,59 @@ function SheetMenuButton({ icon, label, danger = false, disabled = false, onClic
         ]
     });
 }
+const pendingContextRestores = new WeakMap();
+function beginSpreadsheetTableCellRender(_cell, tableStyle, conditionalStyle, context) {
+    if (tableStyle) context.fillStyle = tableStyle.background;
+    if (conditionalStyle?.cellColor) context.fillStyle = conditionalStyle.cellColor;
+    if (!tableStyle || pendingContextRestores.has(context) || 'function' != typeof context.fillText) return;
+    const fillText = context.fillText;
+    pendingContextRestores.set(context, {
+        fillText,
+        fillTextOwned: Object.hasOwn(context, 'fillText')
+    });
+    const textColor = conditionalStyle?.textColor ?? tableStyle.textColor;
+    context.fillText = (text, x, y, maxWidth)=>{
+        const previousFillStyle = context.fillStyle;
+        const previousFont = context.font;
+        context.fillStyle = textColor;
+        if (tableStyle.bold) context.font = boldSpreadsheetTableCanvasFont(context.font);
+        try {
+            if (void 0 === maxWidth) fillText.call(context, text, x, y);
+            else fillText.call(context, text, x, y, maxWidth);
+        } finally{
+            context.fillStyle = previousFillStyle;
+            context.font = previousFont;
+        }
+    };
+}
+function finishSpreadsheetTableCellRender(_cell, cellInfo, tableStyle, context) {
+    if (tableStyle) drawSpreadsheetTableCellBorder(cellInfo, tableStyle, context);
+    const restore = pendingContextRestores.get(context);
+    if (!restore) return;
+    if (restore.fillTextOwned) context.fillText = restore.fillText;
+    else delete context.fillText;
+    pendingContextRestores.delete(context);
+}
+function boldSpreadsheetTableCanvasFont(font) {
+    return /(?:^|\s)(?:bold|[6-9]00)(?:\s|$)/i.test(font) ? font : `bold ${font}`;
+}
+function drawSpreadsheetTableCellBorder(cellInfo, tableStyle, context) {
+    const left = Math.round(cellInfo.startX) + 0.5;
+    const top = Math.round(cellInfo.startY) + 0.5;
+    const right = Math.round(cellInfo.endX) - 0.5;
+    const bottom = Math.round(cellInfo.endY) - 0.5;
+    context.save();
+    context.beginPath();
+    context.strokeStyle = tableStyle.borderColor;
+    context.lineWidth = 'header' === tableStyle.role ? 1 : 0.75;
+    context.moveTo(left, top);
+    context.lineTo(right, top);
+    context.lineTo(right, bottom);
+    context.lineTo(left, bottom);
+    context.closePath();
+    context.stroke();
+    context.restore();
+}
 function validateSpreadsheetChartSeriesTrendlines(series, seriesIndex) {
     for (const [trendlineIndex, trendline] of (series.trendlines ?? []).entries()){
         const prefix = `系列 ${seriesIndex + 1} 的趋势线 ${trendlineIndex + 1}`;
@@ -16195,220 +17808,28 @@ function NamedRangeManager({ content, onChange }) {
                                 onClick: cancelDraft,
                                 children: "取消更改"
                             }),
-                            /*#__PURE__*/ jsx(button_Button, {
-                                type: "submit",
-                                tone: "primary",
-                                disabled: Boolean(draft.id) && !dirty,
-                                children: "保存名称"
-                            })
-                        ]
-                    })
-                ]
-            })
-        ]
-    });
-}
-function rangeDraft(range) {
-    return {
-        id: range?.id,
-        name: range?.name ?? '',
-        reference: range?.reference ?? '',
-        scopeSheetId: range?.scopeSheetId ?? '',
-        comment: range?.comment ?? ''
-    };
-}
-function spreadsheetAutoFilterRange(sheet, selection) {
-    if (sheet.isPivotTable || sheet.pivotTables?.length) return null;
-    const normalized = normalizeAutoFilterSelection(selection);
-    const range = normalized.row[0] !== normalized.row[1] ? normalized : spreadsheetCurrentRegion(sheet, normalized);
-    if (!range || !validSpreadsheetAutoFilterRange(sheet, range)) return null;
-    return range;
-}
-function spreadsheetAutoFilterHeaderColumn(sheet, selection) {
-    const range = normalizedFilterSelection(sheet?.filter_select);
-    if (!sheet || !range) return null;
-    const row = spreadsheet_auto_filter_finiteIndex(selection.row_focus, selection.row[0]);
-    const column = spreadsheet_auto_filter_finiteIndex(selection.column_focus, selection.column[0]);
-    if (row !== range.row[0] || column < range.column[0] || column > range.column[1]) return null;
-    return column;
-}
-function toggleSpreadsheetAutoFilter(content, sheetId, selection) {
-    const sheetIndex = content.sheets.findIndex((sheet)=>sheet.id === sheetId);
-    const sheet = content.sheets[sheetIndex];
-    if (!sheet) return null;
-    const nextSheet = sheet.filter_select ? spreadsheetSheetWithoutAutoFilter(sheet) : spreadsheetSheetWithAutoFilter(sheet, selection);
-    if (!nextSheet) return null;
-    const sheets = [
-        ...content.sheets
-    ];
-    sheets[sheetIndex] = {
-        ...nextSheet,
-        luckysheet_select_save: [
-            finiteSpreadsheetSelection(selection)
-        ]
-    };
-    return {
-        ...content,
-        sheets
-    };
-}
-function spreadsheetSheetWithAutoFilter(sheet, selection) {
-    const range = spreadsheetAutoFilterRange(sheet, selection);
-    if (!range) return null;
-    return {
-        ...sheet,
-        filter: {},
-        filter_select: {
-            row: [
-                ...range.row
-            ],
-            column: [
-                ...range.column
-            ]
-        }
-    };
-}
-function spreadsheetSheetWithoutAutoFilter(sheet) {
-    const hiddenByFilter = spreadsheetFilterHiddenRows(sheet.filter);
-    const rowhidden = {
-        ...sheet.config?.rowhidden
-    };
-    for (const row of hiddenByFilter)delete rowhidden[row];
-    const config = sheet.config ? {
-        ...sheet.config,
-        rowhidden
-    } : void 0;
-    const { filter: _filter, filter_select: _selection, ...remaining } = sheet;
-    return {
-        ...remaining,
-        config
-    };
-}
-function spreadsheetFilterHiddenRows(filter) {
-    const rows = new Set();
-    for (const value of Object.values(filter ?? {})){
-        if (!value || 'object' != typeof value) continue;
-        const rowhidden = value.rowhidden;
-        if (rowhidden && 'object' == typeof rowhidden) for (const row of Object.keys(rowhidden))rows.add(row);
-    }
-    return rows;
-}
-function spreadsheetCurrentRegion(sheet, selection) {
-    const cells = spreadsheetCellReader(sheet);
-    const bounds = spreadsheetUsedBounds(sheet);
-    let startRow = selection.row[0];
-    let endRow = selection.row[1];
-    let startColumn = selection.column[0];
-    let endColumn = selection.column[1];
-    if (startRow > bounds.lastRow || startColumn > bounds.lastColumn || !spreadsheet_auto_filter_spreadsheetCellHasContent(cells(startRow, startColumn))) return null;
-    let changed = true;
-    while(changed){
-        changed = false;
-        while(startColumn > 0 && spreadsheetColumnHasContent(cells, startColumn - 1, startRow, endRow)){
-            startColumn -= 1;
-            changed = true;
-        }
-        while(endColumn < bounds.lastColumn && spreadsheetColumnHasContent(cells, endColumn + 1, startRow, endRow)){
-            endColumn += 1;
-            changed = true;
-        }
-        while(startRow > 0 && spreadsheetRowHasContent(cells, startRow - 1, startColumn, endColumn)){
-            startRow -= 1;
-            changed = true;
-        }
-        while(endRow < bounds.lastRow && spreadsheetRowHasContent(cells, endRow + 1, startColumn, endColumn)){
-            endRow += 1;
-            changed = true;
-        }
-    }
-    return {
-        row: [
-            startRow,
-            endRow
-        ],
-        column: [
-            startColumn,
-            endColumn
+                            /*#__PURE__*/ jsx(button_Button, {
+                                type: "submit",
+                                tone: "primary",
+                                disabled: Boolean(draft.id) && !dirty,
+                                children: "保存名称"
+                            })
+                        ]
+                    })
+                ]
+            })
         ]
-    };
-}
-function validSpreadsheetAutoFilterRange(sheet, range) {
-    if (range.row[1] <= range.row[0]) return false;
-    const cells = spreadsheetCellReader(sheet);
-    if (!spreadsheetRowHasContent(cells, range.row[0], range.column[0], range.column[1])) return false;
-    let dataFound = false;
-    for(let row = range.row[0] + 1; row <= range.row[1]; row += 1)if (spreadsheetRowHasContent(cells, row, range.column[0], range.column[1])) {
-        dataFound = true;
-        break;
-    }
-    return dataFound && !spreadsheetRangeIntersectsMerge(sheet, range);
-}
-function spreadsheetRangeIntersectsMerge(sheet, range) {
-    return Object.values(sheet.config?.merge ?? {}).some((merge)=>{
-        const endRow = merge.r + Math.max(merge.rs, 1) - 1;
-        const endColumn = merge.c + Math.max(merge.cs, 1) - 1;
-        return merge.r <= range.row[1] && endRow >= range.row[0] && merge.c <= range.column[1] && endColumn >= range.column[0];
     });
 }
-function spreadsheetRowHasContent(cellAt, row, startColumn, endColumn) {
-    for(let column = startColumn; column <= endColumn; column += 1)if (spreadsheet_auto_filter_spreadsheetCellHasContent(cellAt(row, column))) return true;
-    return false;
-}
-function spreadsheetColumnHasContent(cellAt, column, startRow, endRow) {
-    for(let row = startRow; row <= endRow; row += 1)if (spreadsheet_auto_filter_spreadsheetCellHasContent(cellAt(row, column))) return true;
-    return false;
-}
-function spreadsheet_auto_filter_spreadsheetCellHasContent(cell) {
-    if (!cell) return false;
-    return [
-        cell.v,
-        cell.m,
-        cell.f
-    ].some((value)=>null != value && '' !== value);
-}
-function spreadsheetCellReader(sheet) {
-    if (sheet.data) return (row, column)=>sheet.data?.[row]?.[column] ?? null;
-    const cells = new Map((sheet.celldata ?? []).map((cell)=>[
-            `${cell.r}:${cell.c}`,
-            cell.v
-        ]));
-    return (row, column)=>cells.get(`${row}:${column}`) ?? null;
-}
-function spreadsheetUsedBounds(sheet) {
-    let lastRow = Math.max((sheet.data?.length ?? 1) - 1, 0);
-    let lastColumn = Math.max(sparseMatrixColumnCount(sheet.data) - 1, 0);
-    for (const cell of sheet.celldata ?? []){
-        lastRow = Math.max(lastRow, cell.r);
-        lastColumn = Math.max(lastColumn, cell.c);
-    }
-    return {
-        lastColumn,
-        lastRow
-    };
-}
-function normalizeAutoFilterSelection(selection) {
-    const startRow = spreadsheet_auto_filter_finiteIndex(selection.row[0], 0);
-    const endRow = spreadsheet_auto_filter_finiteIndex(selection.row[1], startRow);
-    const startColumn = spreadsheet_auto_filter_finiteIndex(selection.column[0], 0);
-    const endColumn = spreadsheet_auto_filter_finiteIndex(selection.column[1], startColumn);
+function rangeDraft(range) {
     return {
-        row: [
-            Math.min(startRow, endRow),
-            Math.max(startRow, endRow)
-        ],
-        column: [
-            Math.min(startColumn, endColumn),
-            Math.max(startColumn, endColumn)
-        ]
+        id: range?.id,
+        name: range?.name ?? '',
+        reference: range?.reference ?? '',
+        scopeSheetId: range?.scopeSheetId ?? '',
+        comment: range?.comment ?? ''
     };
 }
-function normalizedFilterSelection(selection) {
-    if (!selection?.row?.length || !selection.column?.length) return null;
-    return normalizeAutoFilterSelection(selection);
-}
-function spreadsheet_auto_filter_finiteIndex(value, fallback) {
-    return 'number' == typeof value && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : fallback;
-}
 function useSpreadsheetAutoFilter({ canvasRef, content, editable, mountRevision, onChange, selection, sheetId, workbook = null }) {
     const contentRef = useRef(content);
     const editableRef = useRef(editable);
@@ -19984,6 +21405,206 @@ function spreadsheetHyperlinkValidationMessage(content, source, value) {
 function spreadsheetHyperlinkFailureMessage(content, source, value, fallback) {
     return spreadsheetHyperlinkValidationMessage(content, source, value) ?? fallback;
 }
+function SpreadsheetTableDialog({ source, restoreFocusTarget, onApply, onClose, onValidate }) {
+    const [value, setValue] = useState(source.value);
+    const [touched, setTouched] = useState(false);
+    const formId = useId();
+    const validationError = onValidate(value);
+    const visibleError = touched ? validationError : null;
+    const submit = (event)=>{
+        event.preventDefault();
+        setTouched(true);
+        if (validationError) return;
+        if (onApply(value)) onClose();
+    };
+    return /*#__PURE__*/ jsx(Dialog, {
+        title: "创建表格",
+        description: source.sheetName,
+        className: "work-spreadsheet-table-dialog",
+        restoreFocusTarget: restoreFocusTarget,
+        onClose: onClose,
+        footer: /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: "quiet",
+                    onClick: onClose,
+                    children: "取消"
+                }),
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: "primary",
+                    type: "submit",
+                    form: formId,
+                    disabled: Boolean(validationError),
+                    children: "确定"
+                })
+            ]
+        }),
+        children: /*#__PURE__*/ jsxs("form", {
+            id: formId,
+            onSubmit: submit,
+            children: [
+                /*#__PURE__*/ jsxs("div", {
+                    className: "work-spreadsheet-table-scope",
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            "aria-hidden": "true",
+                            children: /*#__PURE__*/ jsx(Table2, {
+                                size: 18
+                            })
+                        }),
+                        /*#__PURE__*/ jsxs("div", {
+                            children: [
+                                /*#__PURE__*/ jsx("strong", {
+                                    children: source.name
+                                }),
+                                /*#__PURE__*/ jsx("small", {
+                                    children: "将连续数据区域转换为原生工作表表格"
+                                })
+                            ]
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsx(field_Field, {
+                    label: "表格区域",
+                    required: true,
+                    error: visibleError ?? void 0,
+                    description: "输入一个连续区域，例如 A1:C20。",
+                    children: /*#__PURE__*/ jsx("input", {
+                        type: "text",
+                        autoCapitalize: "none",
+                        autoFocus: true,
+                        spellCheck: false,
+                        value: value.rangeReference,
+                        onBlur: ()=>setTouched(true),
+                        onChange: (event)=>{
+                            const rangeReference = event.currentTarget.value;
+                            setValue((current)=>({
+                                    ...current,
+                                    rangeReference
+                                }));
+                            setTouched(true);
+                        }
+                    })
+                }),
+                /*#__PURE__*/ jsx(OfficeCheckbox, {
+                    ariaLabel: "表包含标题",
+                    checked: value.headerRow,
+                    onCheckedChange: (headerRow)=>setValue((current)=>({
+                                ...current,
+                                headerRow
+                            })),
+                    children: "表包含标题"
+                })
+            ]
+        })
+    });
+}
+function useSpreadsheetTable({ commandsRef, contentRef, focusGrid, getGridFocusTarget, getLiveSelection, preview }) {
+    const [source, setSource] = useState(null);
+    const invokerRef = useRef(null);
+    const selectionRef = useRef(null);
+    const applyingRef = useRef(false);
+    const appliedRef = useRef(false);
+    useEffect(()=>{
+        if (!preview) return;
+        setSource(null);
+        invokerRef.current = null;
+        selectionRef.current = null;
+        applyingRef.current = false;
+        appliedRef.current = false;
+    }, [
+        preview
+    ]);
+    const open = useCallback((target)=>{
+        if (preview || source) return false;
+        const nextSource = createSpreadsheetTableDialogSource(contentRef.current, target);
+        if (!nextSource) {
+            showToast('请选择包含标题和至少一行数据的连续、未合并区域。', 'error');
+            return false;
+        }
+        const grid = getGridFocusTarget();
+        invokerRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : grid;
+        selectionRef.current = {
+            sheetId: target.sheetId,
+            selection: finiteSpreadsheetSelection(getLiveSelection() ?? target.selection)
+        };
+        appliedRef.current = false;
+        setSource(nextSource);
+        return true;
+    }, [
+        contentRef,
+        getGridFocusTarget,
+        getLiveSelection,
+        preview,
+        source
+    ]);
+    const close = useCallback(()=>{
+        const invoker = invokerRef.current;
+        const grid = getGridFocusTarget();
+        const restoreGrid = appliedRef.current || invoker === grid;
+        setSource(null);
+        requestAnimationFrame(()=>{
+            if (restoreGrid || !invoker?.isConnected) focusGrid(invoker);
+            else invoker.focus({
+                preventScroll: true
+            });
+            if (invokerRef.current === invoker) invokerRef.current = null;
+            selectionRef.current = null;
+            appliedRef.current = false;
+        });
+    }, [
+        focusGrid,
+        getGridFocusTarget
+    ]);
+    const commandPort = useMemo(()=>({
+            canOpen: !preview && null === source,
+            open
+        }), [
+        open,
+        preview,
+        source
+    ]);
+    const selectionForChange = useCallback(()=>applyingRef.current ? selectionRef.current : null, []);
+    return {
+        commandPort,
+        selectionForChange,
+        dialog: source ? /*#__PURE__*/ jsx(SpreadsheetTableDialog, {
+            source: source,
+            restoreFocusTarget: ()=>appliedRef.current ? getGridFocusTarget() : invokerRef.current?.isConnected ? invokerRef.current : getGridFocusTarget(),
+            onApply: (value)=>{
+                const range = spreadsheetTableRangeFromText(value.rangeReference);
+                if (!range) return false;
+                applyingRef.current = true;
+                let handled = false;
+                try {
+                    handled = commandsRef.current?.applyTable({
+                        headerRow: value.headerRow,
+                        name: source.name,
+                        range,
+                        sheetId: source.sheetId
+                    }) ?? false;
+                    appliedRef.current = handled;
+                } finally{
+                    applyingRef.current = false;
+                }
+                if (!handled) showToast(spreadsheetTableValidationMessage(contentRef.current, source, value) ?? '无法创建表格。', 'error');
+                return handled;
+            },
+            onClose: close,
+            onValidate: (value)=>spreadsheetTableValidationMessage(contentRef.current, source, value)
+        }) : null
+    };
+}
+function spreadsheetTableValidationMessage(content, source, value) {
+    const range = spreadsheetTableRangeFromText(value.rangeReference);
+    if (!range) return '请输入一个连续区域。';
+    return spreadsheetTableFailureMessage(content, {
+        headerRow: value.headerRow,
+        name: source.name,
+        range,
+        sheetId: source.sheetId
+    });
+}
 const MAXIMUM_BUFFERED_SPREADSHEET_OPERATIONS = 10001;
 function useSpreadsheetWorkbookSync(content, synchronizeExternalWorkbook) {
     const mountedContentRef = useRef(content);
@@ -20117,6 +21738,14 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
         getLiveSelections: getSpreadsheetDataValidationLiveSelections,
         preview
     });
+    const spreadsheetTable = useSpreadsheetTable({
+        commandsRef: spreadsheetCommandsRef,
+        contentRef,
+        focusGrid: focusSpreadsheetDialogGrid,
+        getGridFocusTarget: getSpreadsheetDialogGridFocusTarget,
+        getLiveSelection: getSpreadsheetHyperlinkLiveSelection,
+        preview
+    });
     const officeDialog = useOfficeDialog();
     const [findOpen, setFindOpen] = useState(false);
     const [findFocusRequest, setFindFocusRequest] = useState(0);
@@ -20149,6 +21778,16 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
     ]);
     const conditionalStylesBySheetRef = useRef(conditionalStylesBySheet);
     conditionalStylesBySheetRef.current = conditionalStylesBySheet;
+    const tableStylesBySheet = useMemo(()=>new Map(materializedContent.sheets.flatMap((sheet)=>sheet.id ? [
+                [
+                    sheet.id,
+                    createSpreadsheetTableRenderResolver(sheet.tables ?? [])
+                ]
+            ] : [])), [
+        materializedContent.sheets
+    ]);
+    const tableStylesBySheetRef = useRef(tableStylesBySheet);
+    tableStylesBySheetRef.current = tableStylesBySheet;
     useEffect(()=>{
         setPreviewActiveSheetId(preview ? contentActiveSheetId : null);
     }, [
@@ -20259,21 +21898,28 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
                         endColumn: Math.max(selection.column[0], selection.column[1])
                     }).length);
             },
-            beforeRenderCell: (_cell, cellInfo, context)=>{
+            beforeRenderCell: (cell, cellInfo, context)=>{
+                const tableStyle = tableStylesBySheetRef.current.get(activeSheetIdRef.current)?.(cellInfo.row, cellInfo.column) ?? null;
                 const style = conditionalStylesBySheetRef.current.get(activeSheetIdRef.current)?.get(`${cellInfo.row}_${cellInfo.column}`);
-                if (style?.cellColor) context.fillStyle = style.cellColor;
+                beginSpreadsheetTableCellRender(cell, tableStyle, style, context);
                 return true;
             },
             afterRenderCell: (cell, cellInfo, context)=>{
+                const tableStyle = tableStylesBySheetRef.current.get(activeSheetIdRef.current)?.(cellInfo.row, cellInfo.column) ?? null;
                 const style = conditionalStylesBySheetRef.current.get(activeSheetIdRef.current)?.get(`${cellInfo.row}_${cellInfo.column}`);
-                if (!style?.icon && !style?.dataBar) return;
-                const background = style.cellColor ?? ('string' == typeof cell?.bg ? cell.bg : '#ffffff');
-                if (style.dataBar) drawSpreadsheetConditionalDataBar(context, cellInfo, {
-                    ...style.dataBar,
-                    showValue: style.dataBar.showValue && (style.icon?.showValue ?? true)
-                }, cell, background, style.textColor);
-                if (style.icon) drawSpreadsheetConditionalIcon(context, cellInfo, style.icon, background, style.dataBar ? false : !style.icon.showValue);
-                if (cell?.ps) drawSpreadsheetCommentMarker(context, cellInfo);
+                try {
+                    if (style?.icon || style?.dataBar) {
+                        const background = style.cellColor ?? tableStyle?.background ?? ('string' == typeof cell?.bg ? cell.bg : '#ffffff');
+                        if (style.dataBar) drawSpreadsheetConditionalDataBar(context, cellInfo, {
+                            ...style.dataBar,
+                            showValue: style.dataBar.showValue && (style.icon?.showValue ?? true)
+                        }, cell, background, style.textColor);
+                        if (style.icon) drawSpreadsheetConditionalIcon(context, cellInfo, style.icon, background, style.dataBar ? false : !style.icon.showValue);
+                        if (cell?.ps) drawSpreadsheetCommentMarker(context, cellInfo);
+                    }
+                } finally{
+                    finishSpreadsheetTableCellRender(cell, cellInfo, tableStyle, context);
+                }
             }
         }), [
         collaborationView
@@ -20393,6 +22039,17 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
     const toolbarColumn = toolbarSelection.column_focus ?? toolbarSelection.column[0];
     const toolbarCell = spreadsheetCellAt(toolbarSheet, toolbarRow, toolbarColumn);
     const toolbarCellBorders = spreadsheetCellBordersAt(toolbarSheet, toolbarRow, toolbarColumn);
+    const toolbarContentSheet = materializedContent.sheets.find((sheet)=>sheet.id === toolbarSheetId);
+    const activeTable = spreadsheetTableAtCell(toolbarContentSheet, toolbarRow, toolbarColumn);
+    const activeTableId = activeTable?.id ?? null;
+    useEffect(()=>{
+        setRibbonTab((current)=>{
+            if (activeTableId) return 'tableDesign' === current ? current : 'tableDesign';
+            return 'tableDesign' === current ? 'home' : current;
+        });
+    }, [
+        activeTableId
+    ]);
     const selectedRange = spreadsheetSingleRange(toolbarSelection);
     const multipleCellsSelected = selectedRange.row[0] !== selectedRange.row[1] || selectedRange.column[0] !== selectedRange.column[1];
     const selectionSummary = multipleCellsSelected ? spreadsheetSelectionSummary(toolbarSheet, toolbarSelection) : null;
@@ -20633,12 +22290,18 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
         onChange: (next)=>{
             const formatCellsSelection = formatCellsApplyingRef.current ? formatCellsSelectionRef.current : null;
             const dataValidationSelection = spreadsheetDataValidation.selectionForChange();
+            const tableSelection = spreadsheetTable.selectionForChange();
             const hyperlinkSelection = spreadsheetHyperlink.selectionForChange();
             const preservedSelection = formatCellsSelection ? {
                 sheetId: formatCellsSelection.sheetId,
                 selections: [
                     formatCellsSelection.selection
                 ]
+            } : tableSelection ? {
+                sheetId: tableSelection.sheetId,
+                selections: [
+                    tableSelection.selection
+                ]
             } : dataValidationSelection ?? (hyperlinkSelection ? {
                 sheetId: hyperlinkSelection.sheetId,
                 selections: [
@@ -20650,6 +22313,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
             onChange(controlled);
         },
         selection: selectionState,
+        table: spreadsheetTable.commandPort,
         targetSheetGridSize,
         targetSheetId: toolbarSheetId,
         toolbarCell,
@@ -20853,6 +22517,8 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
             }),
             !preview && /*#__PURE__*/ jsx(SpreadsheetEditorRibbon, {
                 activeTab: ribbonTab,
+                activeTable: activeTable,
+                activeTableSheetId: activeTable ? toolbarSheetId : void 0,
                 autoFilterActive: autoFilterActive,
                 can: spreadsheetCan,
                 commands: spreadsheetRibbonCommands,
@@ -21075,6 +22741,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
             }),
             spreadsheetDataValidation.dialog,
             spreadsheetHyperlink.dialog,
+            spreadsheetTable.dialog,
             spreadsheetClipboard.dialogSource && /*#__PURE__*/ jsx(SpreadsheetPasteSpecialDialog, {
                 source: spreadsheetClipboard.dialogSource,
                 restoreFocusTarget: spreadsheetClipboard.restoreDialogFocusTarget,
@@ -21187,6 +22854,7 @@ function spreadsheetCommandsWithGridFocus(commands, restoreFocus) {
         cancelFormatPainter: afterSuccessfulCommand(commands.cancelFormatPainter),
         clearSelectedCells: afterSuccessfulCommand(commands.clearSelectedCells),
         copySelection: afterSuccessfulCommand(commands.copySelection),
+        convertTableToRange: afterSuccessfulCommand(commands.convertTableToRange),
         cutSelection: afterSuccessfulCommand(commands.cutSelection),
         deleteSelectedStructure: afterSuccessfulCommand(commands.deleteSelectedStructure),
         fillSelectedCells: afterSuccessfulCommand(commands.fillSelectedCells),