@a3s-lab/office 0.15.0 → 0.17.0

package/dist/0~spreadsheet-editor.js

@@ -1,7 +1,7 @@
 import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Workbook } from "@fortune-sheet/react";
-import { AlignCenter, AlignLeft, AlignRight, AlignVerticalJustifyCenter, AlignVerticalJustifyEnd, AlignVerticalJustifyStart, ArrowDown, ArrowDownToLine, ArrowLeft, ArrowLeftToLine, ArrowRight, ArrowRightToLine, ArrowUp, ArrowUpToLine, BadgeJapaneseYen, BarChart3, BetweenHorizontalEnd, BetweenHorizontalStart, BetweenVerticalEnd, BetweenVerticalStart, Bold, Bookmark, Calculator, Check, ChevronDown, ChevronLeft, ChevronRight, ClipboardPaste, Cloud, Columns3, Copy, CopyPlus, DecimalsArrowLeft, DecimalsArrowRight, Eraser, Eye, EyeOff, FileX2, Globe2, Grid2X2, Grid3X3, Hash, Italic, KeyRound, Layers2, Link2, Link2Off, ListChecks, ListFilter, LocateFixed, Merge, MessageSquareX, MoveHorizontal, MoveVertical, Paintbrush, Palette, PanelLeft, PanelTop, PanelsTopLeft, Pencil, Percent, Plus, Printer, Redo2, RefreshCw, Rows3, Save, Scissors, Search, Settings2, ShieldCheck, Sigma, SortAsc, SortDesc, Strikethrough, SwatchBook, Table2, TableProperties, Trash2, Underline, Undo2, WrapText, X } from "lucide-react";
+import { AArrowDown, AArrowUp, AlignCenter, AlignLeft, AlignRight, AlignVerticalJustifyCenter, AlignVerticalJustifyEnd, AlignVerticalJustifyStart, ArrowDown, ArrowDownToLine, ArrowLeft, ArrowLeftToLine, ArrowRight, ArrowRightToLine, ArrowUp, ArrowUpToLine, BadgeJapaneseYen, BarChart3, BetweenHorizontalEnd, BetweenHorizontalStart, BetweenVerticalEnd, BetweenVerticalStart, Bold, Bookmark, Calculator, Check, ChevronDown, ChevronLeft, ChevronRight, ClipboardPaste, Cloud, Columns3, Copy, CopyPlus, DecimalsArrowLeft, DecimalsArrowRight, Eraser, Eye, EyeOff, FileX2, Globe2, Grid2X2, Grid3X3, Hash, Italic, KeyRound, Layers2, Link2, Link2Off, ListChecks, ListFilter, LocateFixed, Merge, MessageSquareX, MoveHorizontal, MoveVertical, Paintbrush, Palette, PanelLeft, PanelTop, PanelsTopLeft, Pencil, Percent, Plus, Printer, Redo2, RefreshCw, Rows3, Save, Scissors, Search, Settings2, ShieldCheck, Sigma, SortAsc, SortDesc, Strikethrough, SwatchBook, Table2, TableProperties, Trash2, Underline, Undo2, WrapText, X } from "lucide-react";
 import { Fragment as external_react_Fragment, cloneElement, memo, useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { genarate, indexToColumnChar, update as core_update } from "@fortune-sheet/core";
 import { freezeImportedSpreadsheetCell, withoutEditableRange, spreadsheetMatrixProfile, normalizeSpreadsheetConditionalVisualOptions, effectiveSpreadsheetPageSetup, attachSpreadsheetShownCommentCells, withEditableRange, sameSpreadsheetHistoryValue, createOfficeSpreadsheetCollaborationBinding as createWorkOfficeSpreadsheetCollaborationBinding, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconForValue, defaultSpreadsheetConditionalIconThresholds, normalizeSpreadsheetDateValidationBoundary, sheetProtectionAuthority, editableRangeCellCount, unlockedCellCount, registerDerivedSpreadsheetMatrix, editableRangeRequiresCredentials, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, normalizeSpreadsheetConditionalIconSetFormat, defaultSpreadsheetDataBarOptions, spreadsheetConditionalThresholdValue, normalizeSheetProtectionAuthority, withSheetProtection, spreadsheetProtectionKey, defaultSpreadsheetColorScaleThresholds, protectedSheetCount, SPREADSHEET_CONDITIONAL_ICON_SETS, withSheetSelectionPermissions, spreadsheetConditionalComparisonNeedsUpperValue, drawSpreadsheetConditionalIcon, replaceOfficeSpreadsheetCollaboration as replaceWorkOfficeSpreadsheetCollaboration, readOfficeSpreadsheetCollaboration as readWorkOfficeSpreadsheetCollaboration, spreadsheetConditionalThresholdsEqual } from "./2180.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, {
@@ -1373,6 +1373,355 @@ const spreadsheetFontSizes = [
     48,
     72
 ];
+function nextSpreadsheetFontSize(current, direction) {
+    if (!Number.isFinite(current) || current < 1 || current > 409) return null;
+    return 'grow' === direction ? spreadsheetFontSizes.find((size)=>size > current) ?? null : [
+        ...spreadsheetFontSizes
+    ].reverse().find((size)=>size < current) ?? null;
+}
+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));
+}
 function spreadsheetSelectionReference(selection) {
     const rowStart = Math.min(selection.row[0] ?? 0, selection.row[1] ?? selection.row[0] ?? 0);
     const rowEnd = Math.max(selection.row[0] ?? 0, selection.row[1] ?? selection.row[0] ?? 0);
@@ -1622,7 +1971,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 +2000,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 +2638,12 @@ const spreadsheetRibbonTabs = [
         label: '视图'
     }
 ];
+const spreadsheetTableDesignRibbonTab = {
+    id: 'tableDesign',
+    label: '表格设计',
+    compactLabel: '设计',
+    contextual: true
+};
 const spreadsheetCommandCatalog = {
     undo: {
         id: 'history.undo',
@@ -2456,6 +2811,40 @@ const spreadsheetCommandCatalog = {
             ]
         }
     },
+    growFont: {
+        id: 'font.grow',
+        label: '增大字号',
+        location: {
+            area: 'ribbon',
+            tab: 'home',
+            group: 'font'
+        },
+        shortcut: {
+            label: 'Cmd/Ctrl+Shift+. 或 Cmd/Ctrl+]',
+            aria: 'Control+Shift+. Meta+Shift+. Control+] Meta+]',
+            editor: [
+                'Mod-Shift-.',
+                'Mod-]'
+            ]
+        }
+    },
+    shrinkFont: {
+        id: 'font.shrink',
+        label: '减小字号',
+        location: {
+            area: 'ribbon',
+            tab: 'home',
+            group: 'font'
+        },
+        shortcut: {
+            label: 'Cmd/Ctrl+Shift+, 或 Cmd/Ctrl+[',
+            aria: 'Control+Shift+, Meta+Shift+, Control+[ Meta+[',
+            editor: [
+                'Mod-Shift-,',
+                'Mod-['
+            ]
+        }
+    },
     numberFormatGeneral: {
         id: 'number.general',
         label: spreadsheetNumberFormatPresetLabels.general,
@@ -2672,6 +3061,14 @@ const spreadsheetCommandCatalog = {
             area: 'ribbon',
             tab: 'home',
             group: 'font'
+        },
+        shortcut: {
+            label: 'Cmd/Ctrl+Shift+_',
+            aria: 'Control+Shift+_ Meta+Shift+_',
+            editor: [
+                'Mod-Shift-_',
+                'Mod-Shift-Minus'
+            ]
         }
     },
     borderAll: {
@@ -2690,6 +3087,14 @@ const spreadsheetCommandCatalog = {
             area: 'ribbon',
             tab: 'home',
             group: 'font'
+        },
+        shortcut: {
+            label: 'Cmd/Ctrl+Shift+&',
+            aria: 'Control+Shift+& Meta+Shift+&',
+            editor: [
+                'Mod-Shift-&',
+                'Mod-Shift-7'
+            ]
         }
     },
     borderInside: {
@@ -3058,6 +3463,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: '超链接',
@@ -3477,6 +3898,8 @@ function spreadsheet_cell_clear_isRecord(value) {
     return Boolean(value && 'object' == typeof value && !Array.isArray(value));
 }
 function createSpreadsheetCellBorderExtension() {
+    const outsideShortcuts = spreadsheetCommandCatalog.borderOutside.shortcut.editor;
+    const noneShortcuts = spreadsheetCommandCatalog.borderNone.shortcut.editor;
     return createOfficeEditorExtension({
         name: 'spreadsheetCellBorders',
         addCommands: ()=>({
@@ -3484,6 +3907,28 @@ function createSpreadsheetCellBorderExtension() {
                     canExecute: canSetSelectedCellBorders,
                     execute: setSelectedCellBorders
                 }
+            }),
+        addKeyboardShortcuts: ()=>({
+                [outsideShortcuts[0]]: ({ can, commands }, event)=>runSpreadsheetBorderShortcut(event, can.setSelectedCellBorders, commands.setSelectedCellBorders, {
+                        target: 'outside',
+                        color: '#000000',
+                        style: 'thin'
+                    }),
+                [outsideShortcuts[1]]: ({ can, commands }, event)=>runSpreadsheetBorderShortcut(event, can.setSelectedCellBorders, commands.setSelectedCellBorders, {
+                        target: 'outside',
+                        color: '#000000',
+                        style: 'thin'
+                    }),
+                [noneShortcuts[0]]: ({ can, commands }, event)=>runSpreadsheetBorderShortcut(event, can.setSelectedCellBorders, commands.setSelectedCellBorders, {
+                        target: 'none',
+                        color: '#000000',
+                        style: 'thin'
+                    }),
+                [noneShortcuts[1]]: ({ can, commands }, event)=>runSpreadsheetBorderShortcut(event, can.setSelectedCellBorders, commands.setSelectedCellBorders, {
+                        target: 'none',
+                        color: '#000000',
+                        style: 'thin'
+                    })
             })
     });
 }
@@ -3491,15 +3936,22 @@ function canSetSelectedCellBorders(context, format) {
     return Boolean(context.editable && context.workbook && context.targetSheetId && canSetSpreadsheetCellBorders(context.content, context.targetSheetId, liveSpreadsheetBorderRange(context), format));
 }
 function setSelectedCellBorders(context, format) {
-    if (!canSetSelectedCellBorders(context, format)) return false;
-    const next = setSpreadsheetCellBorders(context.content, context.targetSheetId, liveSpreadsheetBorderRange(context), format);
+    if (!context.editable || !context.workbook || !context.targetSheetId) return false;
+    const selection = context.workbook.getSelection()?.at(-1) ?? context.fallbackRange;
+    const range = spreadsheetSingleRange(selection);
+    if (!canSetSpreadsheetCellBorders(context.content, context.targetSheetId, range, format)) return false;
+    const next = setSpreadsheetCellBorders(context.content, context.targetSheetId, range, format);
     if (!next) return false;
-    context.onChange(next);
+    context.onChange(spreadsheetContentWithSelection(next, context.targetSheetId, selection));
     return true;
 }
 function liveSpreadsheetBorderRange(context) {
     return spreadsheetSingleRange(context.workbook?.getSelection()?.at(-1) ?? context.fallbackRange);
 }
+function runSpreadsheetBorderShortcut(event, canExecute, execute, format) {
+    if (event.repeat || isOfficeShortcutBlocked(event.target) || isSpreadsheetNativeTextUndoTarget(event.target) || !canExecute(format)) return false;
+    return execute(format);
+}
 const MAX_SPREADSHEET_PER_CELL_BORDER_CELLS = 10000;
 function setSpreadsheetCellBordersPerCell(content, sheetId, range, formats) {
     const normalizedRange = spreadsheet_cell_range_normalizeSpreadsheetCellRange(range);
@@ -4354,76 +4806,227 @@ function spreadsheetSelectedCellFillPlan(context, direction) {
     const sheet = context.content.sheets.find((candidate)=>candidate.id === context.targetSheetId);
     return canApplySpreadsheetCellFill(sheet, plan) ? plan : null;
 }
-const spreadsheet_go_to_spreadsheetMaximumRows = 1048576;
-const spreadsheet_go_to_spreadsheetMaximumColumns = 16384;
-const spreadsheetGoToMaximumInputLength = 512;
-function resolveSpreadsheetGoToTarget(content, activeSheetId, input) {
-    const value = input.trim().replace(/^=/, '').trim();
-    if (!value) return spreadsheetGoToError('empty');
-    if (value.length > spreadsheetGoToMaximumInputLength) return spreadsheetGoToError('invalid-reference');
-    const activeSheet = content.sheets.find((sheet)=>sheet.id === activeSheetId);
-    if (!activeSheet) return spreadsheetGoToError('sheet-not-found');
-    const qualified = splitSpreadsheetQualifiedReference(value);
-    if (!qualified) return spreadsheetGoToError('invalid-reference');
-    const requestedSheet = qualified.qualifier ? spreadsheetSheetByName(content, qualified.qualifier) : activeSheet;
-    if (qualified.qualifier && !requestedSheet) return spreadsheetGoToError('sheet-not-found');
-    if (requestedSheet?.hide === 1) return spreadsheetGoToError('hidden-sheet');
-    const direct = resolveSpreadsheetDirectRange(content, requestedSheet ?? activeSheet, qualified);
-    if ('error' === direct.kind) return spreadsheetGoToError(direct.code);
-    if ('match' === direct.kind) return spreadsheetGoToSuccess(direct.value, 'reference');
-    const named = findSpreadsheetGoToName(content, qualified.reference, requestedSheet ?? activeSheet, Boolean(qualified.qualifier));
-    if ('error' === named.kind) return spreadsheetGoToError(named.code);
-    if (!named.value) return spreadsheetGoToError('invalid-reference');
-    const fallbackSheet = named.value.scopeSheetId ? content.sheets.find((sheet)=>sheet.id === named.value?.scopeSheetId) : requestedSheet ?? activeSheet;
-    if (!fallbackSheet) return spreadsheetGoToError('sheet-not-found');
-    if (1 === fallbackSheet.hide) return spreadsheetGoToError('hidden-sheet');
-    const namedReference = splitSpreadsheetQualifiedReference(named.value.reference.trim().replace(/^=/, '').trim());
-    if (!namedReference) return spreadsheetGoToError('unsupported-name');
-    const resolved = resolveSpreadsheetDirectRange(content, fallbackSheet, namedReference);
-    if ('error' === resolved.kind) return spreadsheetGoToError(resolved.code);
-    if ('match' !== resolved.kind) return spreadsheetGoToError('unsupported-name');
-    return spreadsheetGoToSuccess(resolved.value, 'named-range', named.value.name);
-}
-function spreadsheetGoToValidationMessage(content, activeSheetId, input) {
-    const resolution = resolveSpreadsheetGoToTarget(content, activeSheetId, input);
-    return resolution.ok ? null : resolution.message;
+const MAX_SPREADSHEET_FONT_SIZE_CELLS = 10000;
+function createSpreadsheetFontSizeExtension() {
+    const growShortcuts = spreadsheetCommandCatalog.growFont.shortcut.editor;
+    const shrinkShortcuts = spreadsheetCommandCatalog.shrinkFont.shortcut.editor;
+    return createOfficeEditorExtension({
+        name: 'spreadsheetFontSize',
+        addCommands: ()=>({
+                adjustFontSize: {
+                    canExecute: canAdjustSelectedFontSize,
+                    execute: adjustSelectedFontSize
+                }
+            }),
+        addKeyboardShortcuts: ()=>({
+                [growShortcuts[0]]: ({ can, commands }, event)=>runSpreadsheetFontSizeShortcut(event, can.adjustFontSize, commands.adjustFontSize, 'grow'),
+                [growShortcuts[1]]: ({ can, commands }, event)=>runSpreadsheetFontSizeShortcut(event, can.adjustFontSize, commands.adjustFontSize, 'grow'),
+                [shrinkShortcuts[0]]: ({ can, commands }, event)=>runSpreadsheetFontSizeShortcut(event, can.adjustFontSize, commands.adjustFontSize, 'shrink'),
+                [shrinkShortcuts[1]]: ({ can, commands }, event)=>runSpreadsheetFontSizeShortcut(event, can.adjustFontSize, commands.adjustFontSize, 'shrink')
+            })
+    });
 }
-function resolveSpreadsheetDirectRange(content, fallbackSheet, qualified) {
-    const sheet = qualified.qualifier ? spreadsheetSheetByName(content, qualified.qualifier) : fallbackSheet;
-    if (!sheet) return {
-        kind: 'error',
-        code: 'sheet-not-found'
-    };
-    if (1 === sheet.hide) return {
-        kind: 'error',
-        code: 'hidden-sheet'
-    };
-    const ranges = parseSpreadsheetCellRanges(qualified.reference);
-    if (!ranges) return {
-        kind: 'miss'
-    };
-    if (1 !== ranges.length) return {
-        kind: 'error',
-        code: 'multiple-ranges'
-    };
-    const range = ranges[0];
-    if (!range || !spreadsheetGoToRangeIsBounded(sheet, range)) return {
-        kind: 'error',
-        code: 'out-of-bounds'
-    };
-    return {
-        kind: 'match',
-        value: {
-            range,
-            sheet
+function spreadsheetFontSizeApiCalls(cells, range, sheetId, direction) {
+    const normalizedRange = spreadsheet_cell_range_normalizeSpreadsheetCellRange(range);
+    if (!normalizedRange || !sheetId || !isSpreadsheetFontSizeDirection(direction) || spreadsheet_cell_range_spreadsheetCellRangeArea(normalizedRange) > MAX_SPREADSHEET_FONT_SIZE_CELLS) return [];
+    const rectangles = [];
+    let active = new Map();
+    const rowCount = normalizedRange.row[1] - normalizedRange.row[0] + 1;
+    const columnCount = normalizedRange.column[1] - normalizedRange.column[0] + 1;
+    for(let rowOffset = 0; rowOffset < rowCount; rowOffset += 1){
+        const row = normalizedRange.row[0] + rowOffset;
+        const runs = spreadsheetFontSizeRowRuns(cells[rowOffset], row, normalizedRange.column[0], columnCount, direction);
+        const nextActive = new Map();
+        for (const run of runs){
+            const signature = `${run.key}:${run.range.column[0]}:${run.range.column[1]}`;
+            const previous = active.get(signature);
+            if (previous && previous.range.row[1] === row - 1) {
+                previous.range.row[1] = row;
+                nextActive.set(signature, previous);
+            } else nextActive.set(signature, run);
         }
-    };
+        for (const [signature, run] of active)if (!nextActive.has(signature)) rectangles.push(run);
+        active = nextActive;
+    }
+    rectangles.push(...active.values());
+    rectangles.sort((left, right)=>left.range.row[0] - right.range.row[0] || left.range.column[0] - right.range.column[0] || left.range.row[1] - right.range.row[1] || left.range.column[1] - right.range.column[1]);
+    return rectangles.map(({ range: targetRange, size })=>({
+            name: 'setCellFormatByRange',
+            args: [
+                'fs',
+                size,
+                targetRange,
+                {
+                    id: sheetId
+                }
+            ]
+        }));
 }
-function findSpreadsheetGoToName(content, input, scopeSheet, qualified) {
-    const normalized = input.trim().toLocaleLowerCase();
-    const matching = (content.namedRanges ?? []).filter((range)=>range.name.trim().toLocaleLowerCase() === normalized);
-    const scoped = matching.filter((range)=>range.scopeSheetId === scopeSheet.id);
-    const workbook = matching.filter((range)=>!range.scopeSheetId);
+function spreadsheetFontSizeRowRuns(cells, row, firstColumn, columnCount, direction) {
+    const runs = [];
+    let current = null;
+    for(let columnOffset = 0; columnOffset < columnCount; columnOffset += 1){
+        const column = firstColumn + columnOffset;
+        const size = adjustedSpreadsheetFontSize(cells?.[columnOffset], direction);
+        if (null === size) {
+            if (current) runs.push(current);
+            current = null;
+            continue;
+        }
+        const key = String(size);
+        if (current && current.key === key) {
+            current.range.column[1] = column;
+            continue;
+        }
+        if (current) runs.push(current);
+        current = {
+            key,
+            range: {
+                row: [
+                    row,
+                    row
+                ],
+                column: [
+                    column,
+                    column
+                ]
+            },
+            size
+        };
+    }
+    if (current) runs.push(current);
+    return runs;
+}
+function adjustedSpreadsheetFontSize(cell, direction) {
+    const size = cell?.fs === void 0 ? 10 : Number(cell.fs);
+    return nextSpreadsheetFontSize(size, direction);
+}
+function canAdjustSelectedFontSize(context, direction) {
+    const workbook = context.workbook;
+    const sheetId = context.targetSheetId;
+    if (!context.editable || !workbook || !sheetId || sheetId !== context.activeSheetId || !isSpreadsheetFontSizeDirection(direction)) return false;
+    const range = liveSpreadsheetFontSizeRange(context);
+    if (spreadsheet_cell_range_spreadsheetCellRangeArea(range) > MAX_SPREADSHEET_FONT_SIZE_CELLS) return false;
+    try {
+        const cells = workbook.getCellsByRange(range, {
+            id: sheetId
+        });
+        return canAdjustSpreadsheetFontSizeCells(range.row[1] - range.row[0] + 1, range.column[1] - range.column[0] + 1, (rowOffset, columnOffset)=>cells[rowOffset]?.[columnOffset] ?? null, direction);
+    } catch  {
+        return false;
+    }
+}
+function adjustSelectedFontSize(context, direction) {
+    const workbook = context.workbook;
+    const sheetId = context.targetSheetId;
+    if (!context.editable || !workbook || !sheetId || sheetId !== context.activeSheetId || !isSpreadsheetFontSizeDirection(direction)) return false;
+    const range = liveSpreadsheetFontSizeRange(context);
+    if (spreadsheet_cell_range_spreadsheetCellRangeArea(range) > MAX_SPREADSHEET_FONT_SIZE_CELLS) return false;
+    try {
+        const cells = workbook.getCellsByRange(range, {
+            id: sheetId
+        });
+        const calls = spreadsheetFontSizeApiCalls(cells, range, sheetId, direction);
+        if (!calls.length) return false;
+        workbook.batchCallApis(calls);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function canAdjustSpreadsheetFontSizeCells(rowCount, columnCount, cellAt, direction) {
+    for(let rowOffset = 0; rowOffset < rowCount; rowOffset += 1)for(let columnOffset = 0; columnOffset < columnCount; columnOffset += 1)if (null !== adjustedSpreadsheetFontSize(cellAt(rowOffset, columnOffset), direction)) return true;
+    return false;
+}
+function liveSpreadsheetFontSizeRange(context) {
+    return spreadsheet_cell_range_normalizeSpreadsheetCellRange(spreadsheetSingleRange(context.workbook?.getSelection()?.at(-1) ?? context.fallbackRange)) ?? {
+        row: [
+            0,
+            0
+        ],
+        column: [
+            0,
+            0
+        ]
+    };
+}
+function isSpreadsheetFontSizeDirection(value) {
+    return 'grow' === value || 'shrink' === value;
+}
+function runSpreadsheetFontSizeShortcut(event, canExecute, execute, direction) {
+    if (event.repeat || isOfficeShortcutBlocked(event.target) || isSpreadsheetNativeTextUndoTarget(event.target) || !canExecute(direction)) return false;
+    return execute(direction);
+}
+const spreadsheet_go_to_spreadsheetMaximumRows = 1048576;
+const spreadsheet_go_to_spreadsheetMaximumColumns = 16384;
+const spreadsheetGoToMaximumInputLength = 512;
+function resolveSpreadsheetGoToTarget(content, activeSheetId, input) {
+    const value = input.trim().replace(/^=/, '').trim();
+    if (!value) return spreadsheetGoToError('empty');
+    if (value.length > spreadsheetGoToMaximumInputLength) return spreadsheetGoToError('invalid-reference');
+    const activeSheet = content.sheets.find((sheet)=>sheet.id === activeSheetId);
+    if (!activeSheet) return spreadsheetGoToError('sheet-not-found');
+    const qualified = splitSpreadsheetQualifiedReference(value);
+    if (!qualified) return spreadsheetGoToError('invalid-reference');
+    const requestedSheet = qualified.qualifier ? spreadsheetSheetByName(content, qualified.qualifier) : activeSheet;
+    if (qualified.qualifier && !requestedSheet) return spreadsheetGoToError('sheet-not-found');
+    if (requestedSheet?.hide === 1) return spreadsheetGoToError('hidden-sheet');
+    const direct = resolveSpreadsheetDirectRange(content, requestedSheet ?? activeSheet, qualified);
+    if ('error' === direct.kind) return spreadsheetGoToError(direct.code);
+    if ('match' === direct.kind) return spreadsheetGoToSuccess(direct.value, 'reference');
+    const named = findSpreadsheetGoToName(content, qualified.reference, requestedSheet ?? activeSheet, Boolean(qualified.qualifier));
+    if ('error' === named.kind) return spreadsheetGoToError(named.code);
+    if (!named.value) return spreadsheetGoToError('invalid-reference');
+    const fallbackSheet = named.value.scopeSheetId ? content.sheets.find((sheet)=>sheet.id === named.value?.scopeSheetId) : requestedSheet ?? activeSheet;
+    if (!fallbackSheet) return spreadsheetGoToError('sheet-not-found');
+    if (1 === fallbackSheet.hide) return spreadsheetGoToError('hidden-sheet');
+    const namedReference = splitSpreadsheetQualifiedReference(named.value.reference.trim().replace(/^=/, '').trim());
+    if (!namedReference) return spreadsheetGoToError('unsupported-name');
+    const resolved = resolveSpreadsheetDirectRange(content, fallbackSheet, namedReference);
+    if ('error' === resolved.kind) return spreadsheetGoToError(resolved.code);
+    if ('match' !== resolved.kind) return spreadsheetGoToError('unsupported-name');
+    return spreadsheetGoToSuccess(resolved.value, 'named-range', named.value.name);
+}
+function spreadsheetGoToValidationMessage(content, activeSheetId, input) {
+    const resolution = resolveSpreadsheetGoToTarget(content, activeSheetId, input);
+    return resolution.ok ? null : resolution.message;
+}
+function resolveSpreadsheetDirectRange(content, fallbackSheet, qualified) {
+    const sheet = qualified.qualifier ? spreadsheetSheetByName(content, qualified.qualifier) : fallbackSheet;
+    if (!sheet) return {
+        kind: 'error',
+        code: 'sheet-not-found'
+    };
+    if (1 === sheet.hide) return {
+        kind: 'error',
+        code: 'hidden-sheet'
+    };
+    const ranges = parseSpreadsheetCellRanges(qualified.reference);
+    if (!ranges) return {
+        kind: 'miss'
+    };
+    if (1 !== ranges.length) return {
+        kind: 'error',
+        code: 'multiple-ranges'
+    };
+    const range = ranges[0];
+    if (!range || !spreadsheetGoToRangeIsBounded(sheet, range)) return {
+        kind: 'error',
+        code: 'out-of-bounds'
+    };
+    return {
+        kind: 'match',
+        value: {
+            range,
+            sheet
+        }
+    };
+}
+function findSpreadsheetGoToName(content, input, scopeSheet, qualified) {
+    const normalized = input.trim().toLocaleLowerCase();
+    const matching = (content.namedRanges ?? []).filter((range)=>range.name.trim().toLocaleLowerCase() === normalized);
+    const scoped = matching.filter((range)=>range.scopeSheetId === scopeSheet.id);
+    const workbook = matching.filter((range)=>!range.scopeSheetId);
     const preferred = scoped.length ? scoped : workbook;
     if (preferred.length > 1) return {
         kind: 'error',
@@ -5048,11 +5651,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);
@@ -5943,54 +6550,946 @@ function orderedSpreadsheetSheets(sheets) {
             index
         })).sort((left, right)=>(left.sheet.order ?? left.index) - (right.sheet.order ?? right.index) || left.index - right.index).map(({ sheet })=>sheet);
 }
-function nextSpreadsheetSheetIdentity(sheets) {
-    const ids = new Set(sheets.map((sheet)=>sheet.id));
-    const names = new Set(sheets.map((sheet)=>sheet.name));
-    let ordinal = sheets.length + 1;
-    while(ids.has(`sheet-${ordinal}`) || names.has(`工作表 ${ordinal}`))ordinal += 1;
+function nextSpreadsheetSheetIdentity(sheets) {
+    const ids = new Set(sheets.map((sheet)=>sheet.id));
+    const names = new Set(sheets.map((sheet)=>sheet.name));
+    let ordinal = sheets.length + 1;
+    while(ids.has(`sheet-${ordinal}`) || names.has(`工作表 ${ordinal}`))ordinal += 1;
+    return {
+        id: `sheet-${ordinal}`,
+        name: `工作表 ${ordinal}`
+    };
+}
+function uniqueSpreadsheetSheetName(sheets, preferred) {
+    const names = new Set(sheets.map((sheet)=>sheet.name));
+    if (!names.has(preferred)) return preferred;
+    let suffix = 2;
+    while(names.has(`${preferred} ${suffix}`))suffix += 1;
+    return `${preferred} ${suffix}`;
+}
+function spreadsheetSelectionAfterStructureDeletion(selection, axis, extent, start, end) {
+    const deletedCount = Math.max(1, end - start + 1);
+    const remainingExtent = Math.max(1, extent - deletedCount);
+    const focus = Math.min(Math.max(0, start), remainingExtent - 1);
+    if ('row' === axis) return {
+        ...selection,
+        row: [
+            focus,
+            focus
+        ],
+        column: [
+            ...selection.column
+        ],
+        ...void 0 === selection.row_focus ? {} : {
+            row_focus: focus
+        }
+    };
+    return {
+        ...selection,
+        row: [
+            ...selection.row
+        ],
+        column: [
+            focus,
+            focus
+        ],
+        ...void 0 === selection.column_focus ? {} : {
+            column_focus: focus
+        }
+    };
+}
+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 {
-        id: `sheet-${ordinal}`,
-        name: `工作表 ${ordinal}`
+        ...content,
+        sheets: content.sheets.map((sheet)=>sheet.id === nextSheet.id ? nextSheet : sheet)
     };
 }
-function uniqueSpreadsheetSheetName(sheets, preferred) {
-    const names = new Set(sheets.map((sheet)=>sheet.name));
-    if (!names.has(preferred)) return preferred;
-    let suffix = 2;
-    while(names.has(`${preferred} ${suffix}`))suffix += 1;
-    return `${preferred} ${suffix}`;
+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 spreadsheetSelectionAfterStructureDeletion(selection, axis, extent, start, end) {
-    const deletedCount = Math.max(1, end - start + 1);
-    const remainingExtent = Math.max(1, extent - deletedCount);
-    const focus = Math.min(Math.max(0, start), remainingExtent - 1);
-    if ('row' === axis) return {
-        ...selection,
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function cloneRange(range) {
+    return {
         row: [
-            focus,
-            focus
+            ...range.row
         ],
         column: [
-            ...selection.column
-        ],
-        ...void 0 === selection.row_focus ? {} : {
-            row_focus: focus
-        }
+            ...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 {
-        ...selection,
-        row: [
-            ...selection.row
-        ],
-        column: [
-            focus,
-            focus
-        ],
-        ...void 0 === selection.column_focus ? {} : {
-            column_focus: focus
-        }
+        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({
@@ -6007,12 +7506,14 @@ function createSpreadsheetEditorExtensions() {
                 })
         }),
         createSpreadsheetCellFormatExtension(),
+        createSpreadsheetFontSizeExtension(),
         createSpreadsheetCellBorderExtension(),
         createSpreadsheetCellStyleExtension(),
         createSpreadsheetNumberFormatExtension(),
         createSpreadsheetNavigationExtension(),
         createSpreadsheetDataValidationExtension(),
         createSpreadsheetHyperlinkExtension(),
+        createSpreadsheetTableExtension(),
         createSpreadsheetAutoSumExtension(),
         createSpreadsheetCellFillExtension(),
         createOfficeEditorExtension({
@@ -6283,9 +7784,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 +7809,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);
@@ -7571,6 +9085,7 @@ function SpreadsheetBorderRibbon({ can, commands }) {
         color
     };
     const currentDefinition = spreadsheetBorderTargetOptions.find((option)=>option.target === target)?.definition;
+    const currentShortcut = currentDefinition && 'shortcut' in currentDefinition ? currentDefinition.shortcut : void 0;
     const currentLabel = currentDefinition?.label ?? '所有框线';
     const styleLabel = spreadsheetBorderStyleOptions.find((option)=>option.value === style)?.label;
     const menuDisabled = spreadsheetBorderTargetOptions.every((option)=>!can.setSelectedCellBorders({
@@ -7593,7 +9108,8 @@ function SpreadsheetBorderRibbon({ can, commands }) {
                         type: "button",
                         className: "work-spreadsheet-border-primary",
                         "aria-label": currentLabel,
-                        title: `${currentLabel}（${styleLabel}，${color.toUpperCase()}）`,
+                        "aria-keyshortcuts": currentShortcut?.aria,
+                        title: `${currentLabel}（${styleLabel}，${color.toUpperCase()}${currentShortcut ? `；${currentShortcut.label}` : ''}）`,
                         disabled: !can.setSelectedCellBorders(format),
                         onClick: ()=>commands.setSelectedCellBorders(format),
                         children: /*#__PURE__*/ jsx(SpreadsheetBorderGlyph, {
@@ -7627,11 +9143,14 @@ function SpreadsheetBorderRibbon({ can, commands }) {
                                 ...format,
                                 target: option
                             };
+                            const shortcut = 'shortcut' in definition ? definition.shortcut : void 0;
                             return /*#__PURE__*/ jsxs("button", {
                                 type: "button",
                                 role: "menuitemradio",
                                 tabIndex: 0 === index ? 0 : -1,
                                 "aria-checked": option === target,
+                                "aria-label": definition.label,
+                                "aria-keyshortcuts": shortcut?.aria,
                                 disabled: !can.setSelectedCellBorders(next),
                                 onClick: ()=>{
                                     setTarget(option);
@@ -7643,7 +9162,11 @@ function SpreadsheetBorderRibbon({ can, commands }) {
                                         target: option
                                     }),
                                     /*#__PURE__*/ jsx("span", {
+                                        className: "work-spreadsheet-border-target-label",
                                         children: definition.label
+                                    }),
+                                    shortcut && /*#__PURE__*/ jsx("kbd", {
+                                        children: shortcut.label
                                     })
                                 ]
                             }, definition.id);
@@ -7783,6 +9306,8 @@ function SpreadsheetFontRibbonGroup({ can, commands, toolbarCell }) {
     const strike = 1 === Number(toolbarCell?.cl);
     const textColor = 'string' == typeof toolbarCell?.fc ? toolbarCell.fc : '#172033';
     const fillColor = 'string' == typeof toolbarCell?.bg ? toolbarCell.bg : '#ffffff';
+    const growFont = spreadsheetCommandCatalog.growFont;
+    const shrinkFont = spreadsheetCommandCatalog.shrinkFont;
     return /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
         label: "字体",
         priority: "high",
@@ -7802,6 +9327,28 @@ function SpreadsheetFontRibbonGroup({ can, commands, toolbarCell }) {
                 options: spreadsheetFontSizeOptions(toolbarCell?.fs),
                 onValueChange: (value)=>commands.setCellFormat('fs', Number(value))
             }),
+            /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
+                label: growFont.label,
+                title: `${growFont.label}（${growFont.shortcut.label}）`,
+                "aria-keyshortcuts": growFont.shortcut.aria,
+                displayLabel: false,
+                disabled: !can.adjustFontSize('grow'),
+                onClick: ()=>commands.adjustFontSize('grow'),
+                children: /*#__PURE__*/ jsx(AArrowUp, {
+                    size: 15
+                })
+            }),
+            /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
+                label: shrinkFont.label,
+                title: `${shrinkFont.label}（${shrinkFont.shortcut.label}）`,
+                "aria-keyshortcuts": shrinkFont.shortcut.aria,
+                displayLabel: false,
+                disabled: !can.adjustFontSize('shrink'),
+                onClick: ()=>commands.adjustFontSize('shrink'),
+                children: /*#__PURE__*/ jsx(AArrowDown, {
+                    size: 15
+                })
+            }),
             /*#__PURE__*/ jsx(SpreadsheetFontToggle, {
                 active: bold,
                 attribute: "bl",
@@ -8654,89 +10201,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 +10558,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 +10571,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 +10803,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 +11014,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 +13918,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 +18080,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 +21677,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 +22010,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 +22050,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 +22170,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 +22311,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 +22562,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 +22585,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
             onChange(controlled);
         },
         selection: selectionState,
+        table: spreadsheetTable.commandPort,
         targetSheetGridSize,
         targetSheetId: toolbarSheetId,
         toolbarCell,
@@ -20853,6 +22789,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 +23013,7 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
             }),
             spreadsheetDataValidation.dialog,
             spreadsheetHyperlink.dialog,
+            spreadsheetTable.dialog,
             spreadsheetClipboard.dialogSource && /*#__PURE__*/ jsx(SpreadsheetPasteSpecialDialog, {
                 source: spreadsheetClipboard.dialogSource,
                 restoreFocusTarget: spreadsheetClipboard.restoreDialogFocusTarget,
@@ -21182,11 +23121,13 @@ function spreadsheetCommandsWithGridFocus(commands, restoreFocus) {
     return {
         ...commands,
         adjustDecimalPlaces: afterSuccessfulCommand(commands.adjustDecimalPlaces),
+        adjustFontSize: afterSuccessfulCommand(commands.adjustFontSize),
         applyAutoSum: afterSuccessfulCommand(commands.applyAutoSum),
         activateFormatPainter: afterSuccessfulCommand(commands.activateFormatPainter),
         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),