@a3s-lab/office 0.20.0 → 0.22.0

package/dist/0~spreadsheet-editor.js

@@ -1,10 +1,10 @@
 import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Workbook } from "@fortune-sheet/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 { 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, CalendarClock, CalendarDays, Check, ChevronDown, ChevronLeft, ChevronRight, ClipboardPaste, Clock, 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, spreadsheetTextOrientationFromChoice, spreadsheetMatrixProfile, withoutEditableRange, spreadsheetTextOrientationFromAngle, isSpreadsheetTextOrientationId, normalizeSpreadsheetConditionalVisualOptions, spreadsheetUnderlineCellValue, effectiveSpreadsheetPageSetup, attachSpreadsheetShownCommentCells, withEditableRange, sameSpreadsheetHistoryValue, createOfficeSpreadsheetCollaborationBinding as createWorkOfficeSpreadsheetCollaborationBinding, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconForValue, defaultSpreadsheetConditionalIconThresholds, spreadsheetUnderlineStyle, normalizeSpreadsheetDateValidationBoundary, sheetProtectionAuthority, editableRangeCellCount, unlockedCellCount, registerDerivedSpreadsheetMatrix, editableRangeRequiresCredentials, spreadsheetTextOrientationCellStyle, normalizeSpreadsheetConditionalIconSetFormat, defaultSpreadsheetDataBarOptions, spreadsheetConditionalThresholdValue, spreadsheetTextOrientationChoiceFromCell, normalizeSheetProtectionAuthority, withSheetProtection, defaultSpreadsheetColorScaleThresholds, spreadsheetProtectionKey, protectedSheetCount, SPREADSHEET_CONDITIONAL_ICON_SETS, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, withSheetSelectionPermissions, spreadsheetConditionalComparisonNeedsUpperValue, drawSpreadsheetConditionalIcon, spreadsheetTextOrientationFromCell, replaceOfficeSpreadsheetCollaboration as replaceWorkOfficeSpreadsheetCollaboration, readOfficeSpreadsheetCollaboration as readWorkOfficeSpreadsheetCollaboration, spreadsheetConditionalThresholdsEqual, isSpreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell } from "./6164.js";
+import { freezeImportedSpreadsheetCell, spreadsheetTextOrientationFromChoice, spreadsheetMatrixProfile, withoutEditableRange, spreadsheetTextOrientationFromAngle, isSpreadsheetTextOrientationId, normalizeSpreadsheetConditionalVisualOptions, spreadsheetCellValueWithDiagonalBorder, spreadsheetUnderlineCellValue, effectiveSpreadsheetPageSetup, attachSpreadsheetShownCommentCells, withEditableRange, sameSpreadsheetHistoryValue, createOfficeSpreadsheetCollaborationBinding as createWorkOfficeSpreadsheetCollaborationBinding, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconForValue, defaultSpreadsheetConditionalIconThresholds, spreadsheetUnderlineStyle, normalizeSpreadsheetDateValidationBoundary, sheetProtectionAuthority, editableRangeCellCount, unlockedCellCount, registerDerivedSpreadsheetMatrix, editableRangeRequiresCredentials, spreadsheetTextOrientationCellStyle, normalizeSpreadsheetConditionalIconSetFormat, defaultSpreadsheetDataBarOptions, spreadsheetConditionalThresholdValue, spreadsheetTextOrientationChoiceFromCell, normalizeSheetProtectionAuthority, withSheetProtection, defaultSpreadsheetColorScaleThresholds, spreadsheetProtectionKey, spreadsheetDiagonalBorderFromCellValue, SPREADSHEET_CONDITIONAL_ICON_SETS, protectedSheetCount, withSheetSelectionPermissions, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, spreadsheetConditionalComparisonNeedsUpperValue, drawSpreadsheetConditionalIcon, spreadsheetTextOrientationFromCell, replaceOfficeSpreadsheetCollaboration as replaceWorkOfficeSpreadsheetCollaboration, readOfficeSpreadsheetCollaboration as readWorkOfficeSpreadsheetCollaboration, spreadsheetConditionalThresholdsEqual, isSpreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell } from "./5045.js";
 import { workSpreadsheetChartSupportsGrouping, createSpreadsheetChartFromSelection, normalizeWorkSpreadsheetDataLabelPosition, normalizeSpreadsheetPrintTitleColumns, normalizeSpreadsheetPrintTitleRows, formulaHasStructuredReference, normalizeWorkSpreadsheetErrorBars, defaultPivotValueCaption, workSpreadsheetChartSupportsBarSpacing, normalizeWorkSpreadsheetChartGrouping, spreadsheetGridSize, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetScatterStyle, cloneSparseMatrix, spreadsheetPivotAggregationLabel, workSpreadsheetChartAxisIsCategoryAxis, reconcileSpreadsheetChartPreviews, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetChartLegendPosition, spreadsheetChartCount, workSpreadsheetChartTypeLabel, sparseArrayEntries, normalizeWorkSpreadsheetTrendline, effectiveSpreadsheetCalculationSettings, spreadsheetPivotIntersects, normalizeWorkSpreadsheetDataLabels, spreadsheetPivotOutputContains, normalizeSpreadsheetPrintArea, spreadsheetCellAddress, formatSpreadsheetCellRanges, normalizeWorkSpreadsheetChartLayout, spreadsheetFormulaRangeForCell, workSpreadsheetChartAxisIsValueAxis, normalizeWorkSpreadsheetChartSmoothLines, spreadsheetPivotFilterValueKey, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetChartSeriesStyle, volatileSpreadsheetFormulaFunctions, sparseArrayIndexes, normalizeWorkSpreadsheetBubbleSizeRepresents, workSpreadsheetChartSupportsTrendlines, normalizeWorkSpreadsheetChartLegendOverlay, parseSpreadsheetChartReference, workSpreadsheetChartGroupingIsStacked, normalizeWorkSpreadsheetChartGapWidth, workSpreadsheetChartSupportsSmoothLines, refreshSpreadsheetPivotTables, createSpreadsheetPivotFromSelection, reconcileSpreadsheetPivots, spreadsheetPivotCount, sparseMatrixColumnCount, workSpreadsheetChartSupportsErrorBars, formulaHasExternalReference, isValidSpreadsheetDefinedName, spreadsheetPivotValidation, deleteSpreadsheetPivotTable, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartSupportsSeriesAnalysis, parseSpreadsheetCellRanges, spreadsheetPivotFilterItems, spreadsheetPivotFields, normalizeWorkSpreadsheetChartOverlap, spreadsheetFormulaRangeConflict, spreadsheetSheetsWithChartPreviews, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartSupportsAxes, normalizeWorkSpreadsheetCombinationSeriesType, normalizeWorkSpreadsheetRadarStyle } from "./8715.js";
 import { moveOfficeMenuFocus, stepOfficeZoom, useOfficeRemoteParticipants, Popover, officePresenceColor, useOfficePublishPresenceLocation, button_Button, icon_button_IconButton, moveOfficeGridMenuFocus, office_text_field_OfficeTextField, useDialogFocusScope, useOfficeEditorWheelZoom } from "./0~6090.js";
 import { useOfficeTaskPaneEscape, OfficeCheckbox, CommittedOfficeNumberField, useOfficeDialog, useOfficeTaskPaneModal, createOfficeKernelClient, officeFontFamilies, CollectionState, OfficeNumberField, handleOfficeTaskPaneKeyDown } from "./0~7048.js";
@@ -86,6 +86,74 @@ function drawCellValue(context, bounds, cell, conditionalTextColor) {
         context.fillText(String(value), bounds.startX + 4, bounds.startY + height / 2, bounds.endX - bounds.startX - 8);
     }
 }
+function drawSpreadsheetDiagonalDownBorder(context, bounds, line) {
+    drawSpreadsheetDiagonalBorder(context, bounds, line, 'down');
+}
+function drawSpreadsheetDiagonalUpBorder(context, bounds, line) {
+    drawSpreadsheetDiagonalBorder(context, bounds, line, 'up');
+}
+function drawSpreadsheetDiagonalBorder(context, bounds, line, direction) {
+    const left = Math.round(bounds.startX) + 0.5;
+    const top = Math.round(bounds.startY) + 0.5;
+    const right = Math.round(bounds.endX) - 1.5;
+    const bottom = Math.round(bounds.endY) - 1.5;
+    if (right <= left || bottom <= top) return;
+    context.save();
+    context.strokeStyle = line.color;
+    context.lineCap = 'butt';
+    context.lineWidth = spreadsheetDiagonalLineWidth(line.style);
+    context.setLineDash(spreadsheetDiagonalLineDash(line.style));
+    const startY = 'down' === direction ? top : bottom;
+    const endY = 'down' === direction ? bottom : top;
+    if ('7' === line.style) {
+        drawLine(context, left, startY - 1, right, endY - 1);
+        drawLine(context, left, startY + 1, right, endY + 1);
+    } else drawLine(context, left, startY, right, endY);
+    context.restore();
+}
+function drawLine(context, startX, startY, endX, endY) {
+    context.beginPath();
+    context.moveTo(startX, startY);
+    context.lineTo(endX, endY);
+    context.stroke();
+}
+function spreadsheetDiagonalLineWidth(style) {
+    if ('2' === style) return 0.5;
+    if ([
+        '8',
+        '9',
+        '10',
+        '11',
+        '12'
+    ].includes(style)) return 2;
+    if ('13' === style) return 3;
+    return 1;
+}
+function spreadsheetDiagonalLineDash(style) {
+    if ('3' === style) return [
+        1,
+        2
+    ];
+    if ('4' === style || '9' === style) return [
+        5,
+        3
+    ];
+    if ('5' === style || '10' === style || '12' === style) return [
+        6,
+        3,
+        1,
+        3
+    ];
+    if ('6' === style || '11' === style) return [
+        6,
+        3,
+        1,
+        3,
+        1,
+        3
+    ];
+    return [];
+}
 function parseSpreadsheetConditionalColor(value) {
     const hexadecimal = /^#?([0-9a-f]{6})$/i.exec(value.trim());
     if (hexadecimal) return {
@@ -577,7 +645,8 @@ const spreadsheetCellBorderTargets = [
     'inside',
     'horizontal',
     'vertical',
-    'diagonal'
+    'diagonalDown',
+    'diagonalUp'
 ];
 const spreadsheetCellBorderStyles = [
     'thin',
@@ -615,8 +684,7 @@ const spreadsheetNativeBorderTypeByTarget = {
     outside: 'border-outside',
     inside: 'border-inside',
     horizontal: 'border-horizontal',
-    vertical: 'border-vertical',
-    diagonal: 'border-slash'
+    vertical: 'border-vertical'
 };
 const spreadsheetNativeBorderStyleByName = {
     thin: '1',
@@ -635,36 +703,29 @@ function spreadsheetNativeBorderStyle(style) {
 }
 function canSetSpreadsheetCellBorders(content, sheetId, range, format) {
     const normalizedRange = spreadsheet_cell_range_normalizeSpreadsheetCellRange(range);
-    return Boolean(content.sheets.some((sheet)=>sheet.id === sheetId) && normalizedRange && normalizeSpreadsheetBorderFormat(format) && ('diagonal' !== format.target || spreadsheet_cell_range_spreadsheetCellRangeArea(normalizedRange) <= MAX_SPREADSHEET_DIAGONAL_BORDER_CELLS) && spreadsheetBorderInfoIsWritable(content.sheets.find((sheet)=>sheet.id === sheetId)));
+    return Boolean(content.sheets.some((sheet)=>sheet.id === sheetId) && normalizedRange && normalizeSpreadsheetBorderFormat(format) && (!isSpreadsheetDiagonalBorderTarget(format.target) || spreadsheet_cell_range_spreadsheetCellRangeArea(normalizedRange) <= MAX_SPREADSHEET_DIAGONAL_BORDER_CELLS) && spreadsheetBorderInfoIsWritable(content.sheets.find((sheet)=>sheet.id === sheetId)));
 }
 function setSpreadsheetCellBorders(content, sheetId, range, format) {
     const sheetIndex = content.sheets.findIndex((sheet)=>sheet.id === sheetId);
     const sheet = content.sheets[sheetIndex];
     const normalizedRange = spreadsheet_cell_range_normalizeSpreadsheetCellRange(range);
     const normalizedFormat = normalizeSpreadsheetBorderFormat(format);
-    if (!sheet || !normalizedRange || !normalizedFormat || !spreadsheetBorderInfoIsWritable(sheet) || 'diagonal' === normalizedFormat.target && spreadsheet_cell_range_spreadsheetCellRangeArea(normalizedRange) > MAX_SPREADSHEET_DIAGONAL_BORDER_CELLS) return null;
-    const borderType = spreadsheetNativeBorderTypeByTarget[normalizedFormat.target];
+    if (!sheet || !normalizedRange || !normalizedFormat || !spreadsheetBorderInfoIsWritable(sheet) || isSpreadsheetDiagonalBorderTarget(normalizedFormat.target) && spreadsheet_cell_range_spreadsheetCellRangeArea(normalizedRange) > MAX_SPREADSHEET_DIAGONAL_BORDER_CELLS) return null;
     const source = Array.isArray(sheet.config?.borderInfo) ? sheet.config.borderInfo : [];
+    if (isSpreadsheetDiagonalBorderTarget(normalizedFormat.target)) {
+        const borderInfo = [
+            ...compactSpreadsheetBorderInfo(source, normalizedRange, 'border-slash'),
+            ...spreadsheetDiagonalBorderRecords(sheet, normalizedRange, normalizedFormat.target, normalizedFormat.color, spreadsheetNativeBorderStyleByName[normalizedFormat.style])
+        ];
+        return contentWithSpreadsheetBorderInfo(content, sheetIndex, sheet, borderInfo);
+    }
+    const borderType = spreadsheetNativeBorderTypeByTarget[normalizedFormat.target];
     const compacted = compactSpreadsheetBorderInfo(source, normalizedRange, borderType);
     const borderInfo = [
         ...compacted,
         ...spreadsheetNativeBorderRecords(normalizedRange, borderType, normalizedFormat.color, spreadsheetNativeBorderStyleByName[normalizedFormat.style])
     ];
-    const nextSheet = {
-        ...sheet,
-        config: {
-            ...sheet.config,
-            borderInfo: borderInfo
-        }
-    };
-    const sheets = [
-        ...content.sheets
-    ];
-    sheets[sheetIndex] = nextSheet;
-    return {
-        ...content,
-        sheets
-    };
+    return contentWithSpreadsheetBorderInfo(content, sheetIndex, sheet, borderInfo);
 }
 function spreadsheetCellBordersAt(sheet, row, column) {
     const borders = {};
@@ -678,7 +739,7 @@ function spreadsheetCellBordersAt(sheet, row, column) {
             applyResolvedCellBorderLine(borders, 'right', candidate.value.r);
             applyResolvedCellBorderLine(borders, 'top', candidate.value.t);
             applyResolvedCellBorderLine(borders, 'bottom', candidate.value.b);
-            applyResolvedCellBorderLine(borders, 'diagonal', candidate.value.s);
+            applyResolvedCellDiagonalBorders(borders, candidate.value);
             continue;
         }
         if ('range' !== candidate.rangeType || !isSpreadsheetNativeBorderType(candidate.borderType) || !Array.isArray(candidate.range)) continue;
@@ -690,6 +751,69 @@ function spreadsheetCellBordersAt(sheet, row, column) {
     }
     return borders;
 }
+function spreadsheetRenderableDiagonalBorders(sheet) {
+    const borders = new Map();
+    const source = Array.isArray(sheet.config?.borderInfo) ? sheet.config.borderInfo : [];
+    for (const candidate of source){
+        if (!spreadsheet_cell_border_isRecord(candidate)) continue;
+        if ('cell' === candidate.rangeType) {
+            if (!spreadsheet_cell_border_isRecord(candidate.value)) continue;
+            const row = finiteSpreadsheetBorderIndex(candidate.value.row_index);
+            const column = finiteSpreadsheetBorderIndex(candidate.value.col_index);
+            if (null === row || null === column) continue;
+            const key = `${row}_${column}`;
+            const diagonal = spreadsheetDiagonalBorderFromCellValue(candidate.value);
+            if (void 0 === diagonal) continue;
+            if (!diagonal) {
+                borders.delete(key);
+                continue;
+            }
+            const line = resolvedCellBorderLine(diagonal.line);
+            if (!line) {
+                borders.delete(key);
+                continue;
+            }
+            borders.set(key, {
+                border: {
+                    ...diagonal.down ? {
+                        down: line
+                    } : {},
+                    ...diagonal.up ? {
+                        up: line
+                    } : {}
+                },
+                column,
+                row
+            });
+            continue;
+        }
+        if ('range' !== candidate.rangeType || 'border-none' !== candidate.borderType && 'border-slash' !== candidate.borderType || !Array.isArray(candidate.range)) continue;
+        const line = resolvedRangeBorderLine(candidate);
+        for (const rangeCandidate of candidate.range){
+            const range = parseSpreadsheetCellRange(rangeCandidate);
+            if (range) {
+                for (const [key, entry] of borders)if (spreadsheetCellRangeContains(range, entry.row, entry.column)) {
+                    if ('border-none' === candidate.borderType || !entry.border.up) {
+                        borders.delete(key);
+                        continue;
+                    }
+                    borders.set(key, {
+                        ...entry,
+                        border: {
+                            up: line ?? entry.border.up
+                        }
+                    });
+                }
+            }
+        }
+    }
+    return new Map([
+        ...borders
+    ].map(([key, entry])=>[
+            key,
+            entry.border
+        ]));
+}
 function normalizeSpreadsheetBorderFormat(format) {
     if (!spreadsheetCellBorderTargets.includes(format.target) || !spreadsheetCellBorderStyles.includes(format.style)) return null;
     const color = normalizeSpreadsheetBorderColor(format.color);
@@ -716,14 +840,26 @@ function compactSpreadsheetBorderInfo(formats, range, appliedType) {
             format
         ];
         if ('cell' === format.rangeType) {
-            if (!supersedesAll || !spreadsheet_cell_border_isRecord(format.value)) return [
+            if (!spreadsheet_cell_border_isRecord(format.value)) return [
                 format
             ];
             const row = finiteSpreadsheetBorderIndex(format.value.row_index);
             const column = finiteSpreadsheetBorderIndex(format.value.col_index);
-            return null !== row && null !== column && spreadsheetCellRangeContains(range, row, column) ? [] : [
+            const selected = null !== row && null !== column && spreadsheetCellRangeContains(range, row, column);
+            if (!selected) return [
                 format
             ];
+            if (supersedesAll) return [];
+            if ('border-slash' !== appliedType) return [
+                format
+            ];
+            const value = spreadsheetCellValueWithDiagonalBorder(format.value, null);
+            return Object.keys(value).some((key)=>'row_index' !== key && 'col_index' !== key) ? [
+                {
+                    ...format,
+                    value
+                }
+            ] : [];
         }
         if ('range' !== format.rangeType || !isSpreadsheetNativeBorderType(format.borderType) || !Array.isArray(format.range) || !supersedesAll && format.borderType !== appliedType) return [
             format
@@ -733,9 +869,14 @@ function compactSpreadsheetBorderInfo(formats, range, appliedType) {
             if (!parsed) return [
                 candidate
             ];
-            if ('border-slash' === format.borderType) return spreadsheetCellRangesIntersect(parsed, range) ? [] : [
-                candidate
-            ];
+            if ('border-slash' === format.borderType) {
+                if (!spreadsheetCellRangesIntersect(parsed, range)) return [
+                    candidate
+                ];
+                return 1 === spreadsheet_cell_range_spreadsheetCellRangeArea(parsed) ? [] : [
+                    candidate
+                ];
+            }
             return subtractSpreadsheetCellRange(parsed, range);
         });
         return remaining.length ? [
@@ -747,7 +888,7 @@ function compactSpreadsheetBorderInfo(formats, range, appliedType) {
     });
 }
 function spreadsheetNativeBorderRecords(range, borderType, color, style) {
-    if ('border-slash' !== borderType) return [
+    return [
         {
             rangeType: 'range',
             borderType,
@@ -758,28 +899,91 @@ function spreadsheetNativeBorderRecords(range, borderType, color, style) {
             ]
         }
     ];
+}
+function spreadsheetDiagonalBorderRecords(sheet, range, target, color, style) {
     const records = [];
-    for(let row = range.row[0]; row <= range.row[1]; row += 1)for(let column = range.column[0]; column <= range.column[1]; column += 1)records.push({
-        rangeType: 'range',
-        borderType,
-        color,
-        style,
-        range: [
-            {
-                row: [
-                    row,
-                    row
-                ],
-                column: [
-                    column,
-                    column
-                ],
-                row_focus: row,
-                column_focus: column
+    const existing = spreadsheetDiagonalBorderDirectionsInRange(sheet, range);
+    for(let row = range.row[0]; row <= range.row[1]; row += 1)for(let column = range.column[0]; column <= range.column[1]; column += 1){
+        const current = existing.get(`${row}_${column}`);
+        const border = {
+            down: 'diagonalDown' === target || Boolean(current?.down),
+            line: {
+                color,
+                style
+            },
+            up: 'diagonalUp' === target || Boolean(current?.up)
+        };
+        records.push({
+            rangeType: 'cell',
+            value: spreadsheetCellValueWithDiagonalBorder({
+                col_index: column,
+                row_index: row
+            }, border)
+        });
+    }
+    return records;
+}
+function spreadsheetDiagonalBorderDirectionsInRange(sheet, selection) {
+    const directions = new Map();
+    const source = Array.isArray(sheet.config?.borderInfo) ? sheet.config.borderInfo : [];
+    for (const candidate of source){
+        if (!spreadsheet_cell_border_isRecord(candidate)) continue;
+        if ('cell' === candidate.rangeType) {
+            if (!spreadsheet_cell_border_isRecord(candidate.value)) continue;
+            const row = finiteSpreadsheetBorderIndex(candidate.value.row_index);
+            const column = finiteSpreadsheetBorderIndex(candidate.value.col_index);
+            if (null === row || null === column || !spreadsheetCellRangeContains(selection, row, column)) continue;
+            const diagonal = spreadsheetDiagonalBorderFromCellValue(candidate.value);
+            if (void 0 === diagonal) continue;
+            const line = diagonal && resolvedCellBorderLine(diagonal.line);
+            setSpreadsheetDiagonalDirections(directions, row, column, Boolean(line && diagonal?.down), Boolean(line && diagonal?.up));
+            continue;
+        }
+        if ('range' !== candidate.rangeType || 'border-none' !== candidate.borderType && 'border-slash' !== candidate.borderType || !Array.isArray(candidate.range)) continue;
+        const line = resolvedRangeBorderLine(candidate);
+        for (const rangeCandidate of candidate.range){
+            const range = parseSpreadsheetCellRange(rangeCandidate);
+            if (!range || !spreadsheetCellRangesIntersect(range, selection)) continue;
+            const startRow = Math.max(range.row[0], selection.row[0]);
+            const endRow = Math.min(range.row[1], selection.row[1]);
+            const startColumn = Math.max(range.column[0], selection.column[0]);
+            const endColumn = Math.min(range.column[1], selection.column[1]);
+            for(let row = startRow; row <= endRow; row += 1)for(let column = startColumn; column <= endColumn; column += 1){
+                if ('border-none' === candidate.borderType) {
+                    directions.delete(`${row}_${column}`);
+                    continue;
+                }
+                const current = directions.get(`${row}_${column}`);
+                setSpreadsheetDiagonalDirections(directions, row, column, Boolean(line), Boolean(current?.up));
             }
-        ]
+        }
+    }
+    return directions;
+}
+function setSpreadsheetDiagonalDirections(directions, row, column, down, up) {
+    const key = `${row}_${column}`;
+    if (!down && !up) return void directions.delete(key);
+    directions.set(key, {
+        down,
+        up
     });
-    return records;
+}
+function contentWithSpreadsheetBorderInfo(content, sheetIndex, sheet, borderInfo) {
+    const nextSheet = {
+        ...sheet,
+        config: {
+            ...sheet.config,
+            borderInfo: borderInfo
+        }
+    };
+    const sheets = [
+        ...content.sheets
+    ];
+    sheets[sheetIndex] = nextSheet;
+    return {
+        ...content,
+        sheets
+    };
 }
 function applyResolvedCellBorderLine(borders, side, value) {
     if (null === value) return void delete borders[side];
@@ -791,6 +995,26 @@ function applyResolvedCellBorderLine(borders, side, value) {
         style
     };
 }
+function applyResolvedCellDiagonalBorders(borders, value) {
+    const diagonal = spreadsheetDiagonalBorderFromCellValue(value);
+    if (void 0 === diagonal) return;
+    delete borders.diagonalDown;
+    delete borders.diagonalUp;
+    if (!diagonal) return;
+    const line = resolvedCellBorderLine(diagonal.line);
+    if (!line) return;
+    if (diagonal.down) borders.diagonalDown = line;
+    if (diagonal.up) borders.diagonalUp = line;
+}
+function resolvedCellBorderLine(value) {
+    if (!spreadsheet_cell_border_isRecord(value)) return null;
+    const color = 'string' == typeof value.color ? normalizeSpreadsheetBorderColor(value.color) : null;
+    const style = 'string' == typeof value.style ? value.style : null;
+    return color && style ? {
+        color,
+        style
+    } : null;
+}
 function resolvedRangeBorderLine(value) {
     const color = 'string' == typeof value.color ? normalizeSpreadsheetBorderColor(value.color) : null;
     const style = 'string' == typeof value.style ? value.style : null;
@@ -826,7 +1050,8 @@ function applyResolvedRangeBorder(borders, range, row, column, type, line) {
             delete borders.bottom;
             delete borders.left;
             delete borders.right;
-            delete borders.diagonal;
+            delete borders.diagonalDown;
+            delete borders.diagonalUp;
             break;
         case 'border-all':
             set('top');
@@ -855,10 +1080,16 @@ function applyResolvedRangeBorder(borders, range, row, column, type, line) {
             if (!onRight) set('right');
             break;
         case 'border-slash':
-            set('diagonal');
+            if (line) {
+                borders.diagonalDown = line;
+                if (borders.diagonalUp) borders.diagonalUp = line;
+            } else delete borders.diagonalDown;
             break;
     }
 }
+function isSpreadsheetDiagonalBorderTarget(target) {
+    return 'diagonalDown' === target || 'diagonalUp' === target;
+}
 function isSpreadsheetNativeBorderType(value) {
     return 'string' == typeof value && spreadsheetNativeBorderTypes.has(value);
 }
@@ -3005,6 +3236,38 @@ const spreadsheetCommandCatalog = {
             group: 'number'
         }
     },
+    insertCurrentDate: {
+        id: 'number.insertCurrentDate',
+        label: '插入当前日期',
+        location: {
+            area: 'ribbon',
+            tab: 'home',
+            group: 'number'
+        },
+        shortcut: {
+            label: 'Ctrl+;',
+            aria: 'Control+;',
+            editor: [
+                'Control-;'
+            ]
+        }
+    },
+    insertCurrentTime: {
+        id: 'number.insertCurrentTime',
+        label: '插入当前时间',
+        location: {
+            area: 'ribbon',
+            tab: 'home',
+            group: 'number'
+        },
+        shortcut: {
+            label: 'Ctrl+Shift+;',
+            aria: 'Control+Shift+;',
+            editor: [
+                'Control-Shift-;'
+            ]
+        }
+    },
     formatCells: {
         id: 'number.formatCells',
         label: '设置单元格格式',
@@ -3127,9 +3390,18 @@ const spreadsheetCommandCatalog = {
             group: 'font'
         }
     },
-    borderDiagonal: {
-        id: 'font.borderDiagonal',
-        label: '斜线框线',
+    borderDiagonalDown: {
+        id: 'font.borderDiagonalDown',
+        label: '斜下框线',
+        location: {
+            area: 'ribbon',
+            tab: 'home',
+            group: 'font'
+        }
+    },
+    borderDiagonalUp: {
+        id: 'font.borderDiagonalUp',
+        label: '斜上框线',
         location: {
             area: 'ribbon',
             tab: 'home',
@@ -4077,14 +4349,16 @@ const MAX_SPREADSHEET_PER_CELL_BORDER_CELLS = 10000;
 function setSpreadsheetCellBordersPerCell(content, sheetId, range, formats) {
     const normalizedRange = spreadsheet_cell_range_normalizeSpreadsheetCellRange(range);
     const normalizedFormats = formats.map(normalizeSpreadsheetBorderFormat);
-    if (!normalizedRange || spreadsheet_cell_range_spreadsheetCellRangeArea(normalizedRange) > MAX_SPREADSHEET_PER_CELL_BORDER_CELLS || normalizedFormats.some((format)=>!format || ![
+    const area = normalizedRange ? spreadsheet_cell_range_spreadsheetCellRangeArea(normalizedRange) : 1 / 0;
+    if (!normalizedRange || area > MAX_SPREADSHEET_PER_CELL_BORDER_CELLS || normalizedFormats.some((format)=>!format || ![
             'top',
             'bottom',
             'left',
             'right',
             'all',
-            'diagonal'
-        ].includes(format.target))) return null;
+            'diagonalDown',
+            'diagonalUp'
+        ].includes(format.target)) || area > 4096 && normalizedFormats.some((format)=>format?.target === 'diagonalDown' || format?.target === 'diagonalUp')) return null;
     const next = setSpreadsheetCellBorders(content, sheetId, normalizedRange, {
         target: 'none',
         color: '#000000',
@@ -4100,6 +4374,9 @@ function setSpreadsheetCellBordersPerCell(content, sheetId, range, formats) {
             row_index: row,
             col_index: column
         };
+        let diagonalDown = false;
+        let diagonalUp = false;
+        let diagonalLine = null;
         for (const format of normalizedFormats){
             if (!format) continue;
             const line = {
@@ -4110,11 +4387,22 @@ function setSpreadsheetCellBordersPerCell(content, sheetId, range, formats) {
             if ('all' === format.target || 'right' === format.target) value.r = line;
             if ('all' === format.target || 'top' === format.target) value.t = line;
             if ('all' === format.target || 'bottom' === format.target) value.b = line;
-            if ('diagonal' === format.target) value.s = line;
+            if ('diagonalDown' === format.target) {
+                diagonalDown = true;
+                diagonalLine = line;
+            }
+            if ('diagonalUp' === format.target) {
+                diagonalUp = true;
+                diagonalLine = line;
+            }
         }
         records.push({
             rangeType: 'cell',
-            value
+            value: diagonalLine && (diagonalDown || diagonalUp) ? spreadsheetCellValueWithDiagonalBorder(value, {
+                down: diagonalDown,
+                line: diagonalLine,
+                up: diagonalUp
+            }) : value
         });
     }
     const borderInfo = [
@@ -4180,8 +4468,9 @@ function canApplySpreadsheetCellFormat(content, request) {
                 'left',
                 'right',
                 'all',
-                'diagonal'
-            ].includes(format.target)) || normalized.some((format)=>format?.target === 'diagonal') && spreadsheet_cell_range_spreadsheetCellRangeArea(range) > 4096) return false;
+                'diagonalDown',
+                'diagonalUp'
+            ].includes(format.target)) || normalized.some((format)=>format?.target === 'diagonalDown' || format?.target === 'diagonalUp') && spreadsheet_cell_range_spreadsheetCellRangeArea(range) > 4096) return false;
     }
     return true;
 }
@@ -4699,14 +4988,16 @@ function sameCellStyleBorders(actual, formats) {
         if ('all' === format.target || 'right' === format.target) expected.right = line;
         if ('all' === format.target || 'top' === format.target) expected.top = line;
         if ('all' === format.target || 'bottom' === format.target) expected.bottom = line;
-        if ('diagonal' === format.target) expected.diagonal = line;
+        if ('diagonalDown' === format.target) expected.diagonalDown = line;
+        if ('diagonalUp' === format.target) expected.diagonalUp = line;
     }
     return [
         'top',
         'bottom',
         'left',
         'right',
-        'diagonal'
+        'diagonalDown',
+        'diagonalUp'
     ].every((side)=>actual[side]?.color === expected[side]?.color && actual[side]?.style === expected[side]?.style);
 }
 function createSpreadsheetCellStyleExtension() {
@@ -5777,6 +6068,207 @@ function clampSpreadsheetDataValidationFocus(value, range) {
     const focus = 'number' == typeof value && Number.isFinite(value) ? Math.trunc(value) : minimum;
     return Math.min(maximum, Math.max(minimum, focus));
 }
+const MAX_SPREADSHEET_ROWS = 1048576;
+const spreadsheetPasteContentOptions = [
+    {
+        value: 'all',
+        label: '全部',
+        richOnly: false
+    },
+    {
+        value: 'formulas',
+        label: '公式',
+        richOnly: false
+    },
+    {
+        value: 'values',
+        label: '值',
+        richOnly: false
+    },
+    {
+        value: 'formats',
+        label: '格式',
+        richOnly: true
+    },
+    {
+        value: 'comments',
+        label: '批注',
+        richOnly: true
+    },
+    {
+        value: 'validation',
+        label: '数据验证',
+        richOnly: true
+    },
+    {
+        value: 'all-except-borders',
+        label: '边框除外的全部',
+        richOnly: true
+    },
+    {
+        value: 'formulas-and-number-formats',
+        label: '公式和数字格式',
+        richOnly: true
+    },
+    {
+        value: 'values-and-number-formats',
+        label: '值和数字格式',
+        richOnly: true
+    },
+    {
+        value: 'column-widths',
+        label: '列宽',
+        richOnly: true
+    }
+];
+const spreadsheetPasteOperationOptions = [
+    {
+        value: 'none',
+        label: '无'
+    },
+    {
+        value: 'add',
+        label: '加'
+    },
+    {
+        value: 'subtract',
+        label: '减'
+    },
+    {
+        value: 'multiply',
+        label: '乘'
+    },
+    {
+        value: 'divide',
+        label: '除'
+    }
+];
+const MILLISECONDS_PER_DAY = 86400000;
+const MINUTES_PER_DAY = 1440;
+const EXCEL_1900_EPOCH_UTC = Date.UTC(1899, 11, 30);
+function spreadsheetDateTimeEntry(kind, now) {
+    if (!Number.isFinite(now.getTime())) return null;
+    if ('date' === kind) {
+        const year = now.getFullYear();
+        const month = now.getMonth();
+        const day = now.getDate();
+        const value = (Date.UTC(year, month, day) - EXCEL_1900_EPOCH_UTC) / MILLISECONDS_PER_DAY;
+        if (!Number.isFinite(value)) return null;
+        return {
+            format: {
+                fa: 'yyyy-MM-dd',
+                t: 'd'
+            },
+            formulaBarValue: `${padDatePart(year, 4)}-${padDatePart(month + 1)}-${padDatePart(day)}`,
+            value
+        };
+    }
+    if ('time' !== kind) return null;
+    const hours = now.getHours();
+    const minutes = now.getMinutes();
+    return {
+        format: {
+            fa: 'hh:mm',
+            t: 'd'
+        },
+        formulaBarValue: `${padDatePart(hours)}:${padDatePart(minutes)}`,
+        value: (60 * hours + minutes) / MINUTES_PER_DAY
+    };
+}
+function createSpreadsheetDateTimeExtension() {
+    return createOfficeEditorExtension({
+        name: 'spreadsheetDateTime',
+        addCommands: ()=>({
+                insertCurrentDateTime: {
+                    canExecute: (context, kind)=>isSpreadsheetDateTimeKind(kind) && null !== spreadsheetDateTimeTarget(context),
+                    execute: insertCurrentSpreadsheetDateTime
+                }
+            }),
+        addKeyboardShortcuts: ()=>({
+                [spreadsheetCommandCatalog.insertCurrentDate.shortcut.editor["0"]]: ({ can, commands }, event)=>runSpreadsheetDateTimeShortcut(event, 'date', can.insertCurrentDateTime, commands.insertCurrentDateTime),
+                [spreadsheetCommandCatalog.insertCurrentTime.shortcut.editor["0"]]: ({ can, commands }, event)=>runSpreadsheetDateTimeShortcut(event, 'time', can.insertCurrentDateTime, commands.insertCurrentDateTime)
+            })
+    });
+}
+function insertCurrentSpreadsheetDateTime(context, kind) {
+    if (!isSpreadsheetDateTimeKind(kind)) return false;
+    const target = spreadsheetDateTimeTarget(context);
+    const entry = spreadsheetDateTimeEntry(kind, new Date());
+    if (!target || !entry || !context.workbook) return false;
+    try {
+        context.workbook.batchCallApis([
+            {
+                name: 'setCellValuesByRange',
+                args: [
+                    [
+                        [
+                            entry.value
+                        ]
+                    ],
+                    target.range,
+                    {
+                        id: target.sheetId
+                    }
+                ]
+            },
+            {
+                name: 'setCellFormatByRange',
+                args: [
+                    'ct',
+                    entry.format,
+                    target.range,
+                    {
+                        id: target.sheetId
+                    }
+                ]
+            }
+        ]);
+    } catch  {
+        return false;
+    }
+    try {
+        context.formulaBar?.setValue(entry.formulaBarValue);
+    } catch  {}
+    return true;
+}
+function spreadsheetDateTimeTarget(context) {
+    const workbook = context.workbook;
+    const sheetId = context.targetSheetId;
+    if (!context.editable || !workbook || !sheetId || sheetId !== context.activeSheetId) return null;
+    try {
+        const selection = finiteSpreadsheetSelection(workbook.getSelection()?.at(-1) ?? context.fallbackRange);
+        const row = selection.row_focus ?? selection.row[0] ?? 0;
+        const column = selection.column_focus ?? selection.column[0] ?? 0;
+        if (!Number.isSafeInteger(row) || row < 0 || row >= MAX_SPREADSHEET_ROWS || !Number.isSafeInteger(column) || column < 0 || column >= 16384) return null;
+        const range = {
+            row: [
+                row,
+                row
+            ],
+            column: [
+                column,
+                column
+            ]
+        };
+        const sheet = context.content.sheets.find((candidate)=>candidate.id === sheetId);
+        return canMutateSpreadsheetCellRange(sheet, range) ? {
+            range,
+            sheetId
+        } : null;
+    } catch  {
+        return null;
+    }
+}
+function runSpreadsheetDateTimeShortcut(event, kind, canExecute, execute) {
+    if (event.repeat || event.isComposing || isOfficeShortcutBlocked(event.target) || isSpreadsheetNativeTextUndoTarget(event.target) || !isSpreadsheetGridKeyboardTarget(event.target) || !canExecute(kind)) return false;
+    return execute(kind);
+}
+function isSpreadsheetDateTimeKind(value) {
+    return 'date' === value || 'time' === value;
+}
+function padDatePart(value, length = 2) {
+    return String(value).padStart(length, '0');
+}
 function canApplySpreadsheetCellMerge(sheet, range, command) {
     if (!sheet) return false;
     const normalized = normalizeSpreadsheetCellMergeRange(range);
@@ -8109,6 +8601,7 @@ function createSpreadsheetEditorExtensions() {
         createSpreadsheetCellBorderExtension(),
         createSpreadsheetCellStyleExtension(),
         createSpreadsheetNumberFormatExtension(),
+        createSpreadsheetDateTimeExtension(),
         createSpreadsheetNavigationExtension(),
         createSpreadsheetDataValidationExtension(),
         createSpreadsheetHyperlinkExtension(),
@@ -10195,8 +10688,12 @@ const spreadsheetBorderTargetOptions = [
         definition: spreadsheetCommandCatalog.borderVertical
     },
     {
-        target: 'diagonal',
-        definition: spreadsheetCommandCatalog.borderDiagonal
+        target: 'diagonalDown',
+        definition: spreadsheetCommandCatalog.borderDiagonalDown
+    },
+    {
+        target: 'diagonalUp',
+        definition: spreadsheetCommandCatalog.borderDiagonalUp
     }
 ];
 function SpreadsheetBorderRibbon({ can, commands }) {
@@ -10458,6 +10955,73 @@ function SpreadsheetUnderlineGlyph({ style }) {
         })
     });
 }
+function SpreadsheetDateTimeMenu({ can, commands }) {
+    const items = [
+        {
+            definition: spreadsheetCommandCatalog.insertCurrentDate,
+            icon: /*#__PURE__*/ jsx(CalendarDays, {
+                size: 16
+            }),
+            kind: 'date'
+        },
+        {
+            definition: spreadsheetCommandCatalog.insertCurrentTime,
+            icon: /*#__PURE__*/ jsx(Clock, {
+                size: 16
+            }),
+            kind: 'time'
+        }
+    ];
+    const disabled = items.every(({ kind })=>!can.insertCurrentDateTime(kind));
+    return /*#__PURE__*/ jsx(Popover, {
+        label: "日期和时间",
+        panelLabel: "插入日期和时间",
+        panelRole: "menu",
+        portal: true,
+        className: "work-spreadsheet-ribbon-menu-root",
+        panelClassName: "work-office-context-menu work-spreadsheet-ribbon-menu",
+        disabled: disabled,
+        focusFirstOnOpen: true,
+        onPanelKeyDown: moveOfficeMenuFocus,
+        trigger: (triggerProps, { open })=>/*#__PURE__*/ jsxs("button", {
+                ...triggerProps,
+                className: `with-label work-spreadsheet-ribbon-menu-trigger work-spreadsheet-date-time-trigger${open ? ' active' : ''}`,
+                title: "插入当前日期或时间（Ctrl+; / Ctrl+Shift+;）",
+                children: [
+                    /*#__PURE__*/ jsx(CalendarClock, {
+                        size: 19
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        children: "日期和时间"
+                    })
+                ]
+            }),
+        children: (close)=>items.map(({ definition, icon, kind })=>/*#__PURE__*/ jsxs("button", {
+                    type: "button",
+                    role: "menuitem",
+                    tabIndex: -1,
+                    "aria-label": definition.label,
+                    "aria-keyshortcuts": definition.shortcut.aria,
+                    disabled: !can.insertCurrentDateTime(kind),
+                    onClick: ()=>{
+                        close();
+                        commands.insertCurrentDateTime(kind);
+                    },
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            className: "work-spreadsheet-ribbon-menu-item-icon",
+                            children: icon
+                        }),
+                        /*#__PURE__*/ jsx("span", {
+                            children: definition.label
+                        }),
+                        /*#__PURE__*/ jsx("kbd", {
+                            children: definition.shortcut.label
+                        })
+                    ]
+                }, definition.id))
+    });
+}
 const spreadsheetNumberFormatOptions = [
     {
         value: 'general',
@@ -10655,16 +11219,25 @@ function SpreadsheetNumberRibbonGroup({ can, commands, toolbarCell }) {
         label: "数字",
         priority: "high",
         children: [
-            /*#__PURE__*/ jsx(OfficeSelect, {
-                className: "work-spreadsheet-number-format",
-                ariaLabel: "数字格式",
-                value: numberFormatPreset,
-                disabled: !can.setCellFormat('ct', currentNumberFormatValue),
-                options: spreadsheetNumberFormatOptions,
-                onValueChange: (preset)=>{
-                    if ('custom' === preset) return;
-                    commands.setCellFormat('ct', spreadsheetNumberFormatValue(spreadsheetNumberFormatCode(preset), toolbarCell));
-                }
+            /*#__PURE__*/ jsxs("div", {
+                className: "work-spreadsheet-number-format-stack",
+                children: [
+                    /*#__PURE__*/ jsx(OfficeSelect, {
+                        className: "work-spreadsheet-number-format",
+                        ariaLabel: "数字格式",
+                        value: numberFormatPreset,
+                        disabled: !can.setCellFormat('ct', currentNumberFormatValue),
+                        options: spreadsheetNumberFormatOptions,
+                        onValueChange: (preset)=>{
+                            if ('custom' === preset) return;
+                            commands.setCellFormat('ct', spreadsheetNumberFormatValue(spreadsheetNumberFormatCode(preset), toolbarCell));
+                        }
+                    }),
+                    /*#__PURE__*/ jsx(SpreadsheetDateTimeMenu, {
+                        can: can,
+                        commands: commands
+                    })
+                ]
             }),
             /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
                 label: `${currencyDefinition.label}格式`,
@@ -12680,8 +13253,12 @@ const borderTargets = [
         label: '右框线'
     },
     {
-        target: 'diagonal',
-        label: '对角线'
+        target: 'diagonalDown',
+        label: '斜下框线'
+    },
+    {
+        target: 'diagonalUp',
+        label: '斜上框线'
     }
 ];
 function SpreadsheetFormatCellsPanel(props) {
@@ -13114,10 +13691,16 @@ function BorderPreview({ draft }) {
                     borderRight: line('right')
                 }
             }),
-            line('diagonal') && /*#__PURE__*/ jsx("span", {
-                className: "diagonal",
+            line('diagonalDown') && /*#__PURE__*/ jsx("span", {
+                className: "diagonal-down",
+                style: {
+                    borderTop: line('diagonalDown')
+                }
+            }),
+            line('diagonalUp') && /*#__PURE__*/ jsx("span", {
+                className: "diagonal-up",
                 style: {
-                    borderTop: line('diagonal')
+                    borderTop: line('diagonalUp')
                 }
             }),
             /*#__PURE__*/ jsx("strong", {
@@ -13388,7 +13971,8 @@ function borderFormatsAt(sheet, row, column) {
         'bottom',
         'left',
         'right',
-        'diagonal'
+        'diagonalDown',
+        'diagonalUp'
     ].flatMap((target)=>{
         const line = resolved[target];
         if (!line) return [];
@@ -13510,81 +14094,6 @@ function formatCellsSelectionDescription(source) {
     const columns = source.range.column[1] - source.range.column[0] + 1;
     return `设置当前选区的数字、对齐、字体、边框、填充和保护属性（${rows} 行 × ${columns} 列）。`;
 }
-const MAX_SPREADSHEET_ROWS = 1048576;
-const spreadsheetPasteContentOptions = [
-    {
-        value: 'all',
-        label: '全部',
-        richOnly: false
-    },
-    {
-        value: 'formulas',
-        label: '公式',
-        richOnly: false
-    },
-    {
-        value: 'values',
-        label: '值',
-        richOnly: false
-    },
-    {
-        value: 'formats',
-        label: '格式',
-        richOnly: true
-    },
-    {
-        value: 'comments',
-        label: '批注',
-        richOnly: true
-    },
-    {
-        value: 'validation',
-        label: '数据验证',
-        richOnly: true
-    },
-    {
-        value: 'all-except-borders',
-        label: '边框除外的全部',
-        richOnly: true
-    },
-    {
-        value: 'formulas-and-number-formats',
-        label: '公式和数字格式',
-        richOnly: true
-    },
-    {
-        value: 'values-and-number-formats',
-        label: '值和数字格式',
-        richOnly: true
-    },
-    {
-        value: 'column-widths',
-        label: '列宽',
-        richOnly: true
-    }
-];
-const spreadsheetPasteOperationOptions = [
-    {
-        value: 'none',
-        label: '无'
-    },
-    {
-        value: 'add',
-        label: '加'
-    },
-    {
-        value: 'subtract',
-        label: '减'
-    },
-    {
-        value: 'multiply',
-        label: '乘'
-    },
-    {
-        value: 'divide',
-        label: '除'
-    }
-];
 function captureSpreadsheetClipboardSnapshot(content, sheetId, selection, plainText) {
     const range = spreadsheet_cell_range_normalizeSpreadsheetCellRange(selection);
     const sheet = content.sheets.find((candidate)=>candidate.id === sheetId);
@@ -20326,20 +20835,22 @@ function applySpreadsheetPasteBorders(content, sheetId, snapshot, plan, processe
             [
                 'bottom',
                 'b'
-            ],
-            [
-                'diagonal',
-                's'
             ]
         ];
         for (const [side, key] of sides){
             const line = source.borders[side];
             if (line) value[key] = structuredClone(line);
         }
-        return Object.keys(value).length > 2 ? [
+        const diagonal = source.borders.diagonalUp ?? source.borders.diagonalDown ?? null;
+        const withDiagonal = diagonal ? spreadsheetCellValueWithDiagonalBorder(value, {
+            down: Boolean(source.borders.diagonalDown),
+            line: structuredClone(diagonal),
+            up: Boolean(source.borders.diagonalUp)
+        }) : value;
+        return Object.keys(withDiagonal).length > 2 ? [
             {
                 rangeType: 'cell',
-                value
+                value: withDiagonal
             }
         ] : [];
     });
@@ -22627,6 +23138,16 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
     ]);
     const tableStylesBySheetRef = useRef(tableStylesBySheet);
     tableStylesBySheetRef.current = tableStylesBySheet;
+    const diagonalBordersBySheet = useMemo(()=>new Map(materializedContent.sheets.flatMap((sheet)=>sheet.id ? [
+                [
+                    sheet.id,
+                    spreadsheetRenderableDiagonalBorders(sheet)
+                ]
+            ] : [])), [
+        materializedContent.sheets
+    ]);
+    const diagonalBordersBySheetRef = useRef(diagonalBordersBySheet);
+    diagonalBordersBySheetRef.current = diagonalBordersBySheet;
     useEffect(()=>{
         setPreviewActiveSheetId(preview ? contentActiveSheetId : null);
     }, [
@@ -22758,6 +23279,9 @@ function SpreadsheetEditorSurface({ autoFocus = true, content, collaborationHist
                     }
                 } finally{
                     finishSpreadsheetTableCellRender(cell, cellInfo, tableStyle, context);
+                    const diagonal = diagonalBordersBySheetRef.current.get(activeSheetIdRef.current)?.get(`${cellInfo.row}_${cellInfo.column}`);
+                    if (diagonal?.down) drawSpreadsheetDiagonalDownBorder(context, cellInfo, diagonal.down);
+                    if (diagonal?.up) drawSpreadsheetDiagonalUpBorder(context, cellInfo, diagonal.up);
                 }
             }
         }), [
@@ -23699,6 +24223,7 @@ function spreadsheetCommandsWithGridFocus(commands, restoreFocus) {
         deleteSelectedStructure: afterSuccessfulCommand(commands.deleteSelectedStructure),
         fillSelectedCells: afterSuccessfulCommand(commands.fillSelectedCells),
         insertSelectedStructure: afterSuccessfulCommand(commands.insertSelectedStructure),
+        insertCurrentDateTime: afterSuccessfulCommand(commands.insertCurrentDateTime),
         mergeSelectedCells: afterSuccessfulCommand(commands.mergeSelectedCells),
         openPasteSpecial: afterSuccessfulCommand(commands.openPasteSpecial),
         pasteSelection: afterSuccessfulCommand(commands.pasteSelection),