@a3s-lab/office 0.42.0 → 0.44.0

package/dist/{5416.js → 610.js}

@@ -1,9 +1,10 @@
-import { formulaHasStructuredReference, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, formulaHasExternalReference, spreadsheetFormulaFunctions, editableSpreadsheetFormula, isValidSpreadsheetDefinedName } from "./8715.js";
-import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
+import { Parser, SUPPORTED_FORMULAS } from "@fortune-sheet/formula-parser";
+import { sparseMatrixColumnCount, formulaHasStructuredReference, sparseArrayIndexes, formulaHasExternalReference, spreadsheetFormulaFunctions, editableSpreadsheetFormula, formatSpreadsheetCellRanges, isValidSpreadsheetDefinedName, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, cloneSparseMatrix, parseSpreadsheetCellRanges } from "./8715.js";
+import { workOfficeCollaborationJsonEqual, isOfficeShortcutBlocked, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./816.js";
 import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
-import { directChild, directChildren, descendants, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, attribute } from "./4121.js";
+import { directChildren, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, normalizeCssColor, officeFontFamilies, directChild, descendants, attribute, normalizeFormulaForFortuneParser } from "./6968.js";
 import { patchWorkOfficeCollaborationFlatJsonMap, readWorkOfficeCollaborationFlatJsonMap } from "./7060.js";
-import { resolveXlsxColor, createXlsxColorResolver, normalizeXlsxSemanticColorOrigin, xlsxPatternFillKey, XLSX_PATTERN_FILL_CELL_KEY, xlsxCellAddress, xlsxSemanticColorMatchesValue, xlsxGradientFillSemanticColors, xlsxColorElementMatchesOrigin, decodeXlsxCellAddress, xlsxSemanticColorOriginSupported, deleteXlsxPatternFill, xlsxCellStyleOrigin, xlsxRgbColor, xlsxPatternFillSemanticColors, activeXlsxGradientFill, xlsxGradientFillKey, applyXlsxSemanticColorOrigin, deleteXlsxGradientFill, XLSX_GRADIENT_FILL_CELL_KEY, readXlsxSemanticColorOrigin, activeXlsxPatternFill } from "./9333.js";
+import { freezeImportedSpreadsheetCell, normalizeXlsxSemanticColorOrigin, spreadsheetMatrixProfile, withXlsxPatternFill, xlsxCellAddress, xlsxSemanticColorMatchesValue, normalizeSpreadsheetConditionalVisualOptions, xlsxColorElementMatchesOrigin, xlsxGradientFillSemanticColors, withXlsxGradientFill, deleteXlsxPatternFill, activeXlsxGradientFill, xlsxCellStyleOrigin, attachSpreadsheetShownCommentCells, normalizeXlsxPatternFill, decodeXlsxCellAddress, sameSpreadsheetHistoryValue, spreadsheetConditionalIconForValue, XLSX_GRADIENT_FILL_CELL_KEY, readXlsxSemanticColorOrigin, normalizeXlsxGradientFill, xlsxGradientFillFallbackColor, activeXlsxPatternFill, resolveXlsxColor, registerDerivedSpreadsheetMatrix, xlsxPatternFillKey, XLSX_PATTERN_FILL_CELL_KEY, normalizeSpreadsheetConditionalIconSetFormat, spreadsheetConditionalThresholdValue, defaultSpreadsheetDataBarOptions, createXlsxColorResolver, defaultSpreadsheetColorScaleThresholds, xlsxSemanticColorOriginSupported, xlsxRgbColor, xlsxPatternFillSemanticColors, xlsxGradientFillKey, applyXlsxSemanticColorOrigin, deleteXlsxGradientFill, isSpreadsheetConditionalIconSetName, spreadsheetConditionalIconAppearance, spreadsheetConditionalIconSetCount } from "./9333.js";
 import * as __rspack_external_yjs from "yjs";
 const MAX_SPREADSHEET_TABLE_CALCULATED_FORMULA_LENGTH = 8192;
 const UNSAFE_SPREADSHEET_TABLE_CALCULATED_FUNCTIONS = new Set([
@@ -1371,7 +1372,7 @@ function patchSpreadsheetCells(record, previous, next) {
     for (const entry of before){
         if (afterByCoordinate.has(entry.coordinate)) continue;
         if (!presence.has(entry.coordinate)) continue;
-        const current = readCell(fields, entry.row, entry.column);
+        const current = office_spreadsheet_collaboration_cells_readCell(fields, entry.row, entry.column);
         if (!workOfficeCollaborationJsonEqual(entry.cell, current)) throw staleSpreadsheetConflict(`Cell '${entry.coordinate}' in sheet '${next.id}' changed before it was deleted`);
         presence.delete(entry.coordinate);
         deleteCellFields(fields, entry.row, entry.column);
@@ -1406,7 +1407,7 @@ function readSpreadsheetCells(record, sheet) {
         const entry = grouped.get(coordinate);
         if (!entry || value instanceof __rspack_external_yjs.AbstractType) invalidWorkOfficeSpreadsheetShared(`cell field '${encoded}'`);
     }
-    for (const entry of grouped.values())entry.cell = readCell(fields, entry.row, entry.column);
+    for (const entry of grouped.values())entry.cell = office_spreadsheet_collaboration_cells_readCell(fields, entry.row, entry.column);
     const entries = Array.from(grouped.values()).sort((left, right)=>left.row - right.row || left.column - right.column);
     const mode = optionalCellMode(record.get(SPREADSHEET_RECORD_CELL_MODE));
     if (void 0 === mode) {
@@ -1458,7 +1459,7 @@ function spreadsheetCellEntries(sheet) {
 function patchCellFields(target, previous, next, row, column, sheetId) {
     patchSpreadsheetFlatJsonMap(new SpreadsheetCellFieldView(target, row, column), previous, next, `cell '${row}:${column}' in sheet '${sheetId}'`);
 }
-function readCell(target, row, column) {
+function office_spreadsheet_collaboration_cells_readCell(target, row, column) {
     return readSpreadsheetFlatJsonMap(new SpreadsheetCellFieldView(target, row, column), `cell '${row}:${column}'`);
 }
 function patchCellProjectionMetadata(record, rowLengths, previous, next) {
@@ -1832,18 +1833,18 @@ const SPREADSHEET_PRINT_AREAS_ROOT = 'spreadsheet.print-areas';
 const SPREADSHEET_PRINT_TITLES_ROOT = 'spreadsheet.print-titles';
 const SPREADSHEET_PAGE_BREAKS_ROOT = 'spreadsheet.page-breaks';
 const SPREADSHEET_PAGE_SETUPS_ROOT = 'spreadsheet.page-setups';
-function workOfficeSpreadsheetRoots(document, rootName) {
+function workOfficeSpreadsheetRoots(document1, rootName) {
     return {
-        options: document.getMap(rootName(SPREADSHEET_OPTIONS_ROOT)),
-        sheets: document.getMap(rootName(SPREADSHEET_SHEETS_ROOT)),
-        sheetOrder: document.getArray(rootName(SPREADSHEET_SHEET_ORDER_ROOT)),
-        namedRanges: document.getMap(rootName(SPREADSHEET_NAMED_RANGES_ROOT)),
-        namedRangeOrder: document.getArray(rootName(SPREADSHEET_NAMED_RANGE_ORDER_ROOT)),
-        recordClaims: document.getArray(rootName(SPREADSHEET_RECORD_CLAIMS_ROOT)),
-        printAreas: document.getMap(rootName(SPREADSHEET_PRINT_AREAS_ROOT)),
-        printTitles: document.getMap(rootName(SPREADSHEET_PRINT_TITLES_ROOT)),
-        pageBreaks: document.getMap(rootName(SPREADSHEET_PAGE_BREAKS_ROOT)),
-        pageSetups: document.getMap(rootName(SPREADSHEET_PAGE_SETUPS_ROOT))
+        options: document1.getMap(rootName(SPREADSHEET_OPTIONS_ROOT)),
+        sheets: document1.getMap(rootName(SPREADSHEET_SHEETS_ROOT)),
+        sheetOrder: document1.getArray(rootName(SPREADSHEET_SHEET_ORDER_ROOT)),
+        namedRanges: document1.getMap(rootName(SPREADSHEET_NAMED_RANGES_ROOT)),
+        namedRangeOrder: document1.getArray(rootName(SPREADSHEET_NAMED_RANGE_ORDER_ROOT)),
+        recordClaims: document1.getArray(rootName(SPREADSHEET_RECORD_CLAIMS_ROOT)),
+        printAreas: document1.getMap(rootName(SPREADSHEET_PRINT_AREAS_ROOT)),
+        printTitles: document1.getMap(rootName(SPREADSHEET_PRINT_TITLES_ROOT)),
+        pageBreaks: document1.getMap(rootName(SPREADSHEET_PAGE_BREAKS_ROOT)),
+        pageSetups: document1.getMap(rootName(SPREADSHEET_PAGE_SETUPS_ROOT))
     };
 }
 function initializeWorkOfficeSpreadsheetRoots(roots, content) {
@@ -3145,11 +3146,4264 @@ function isoDateFromTimestamp(timestamp) {
     if (!Number.isFinite(timestamp) || year < 1900 || year > 9999) return null;
     return `${String(year).padStart(4, '0')}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(date.getUTCDate()).padStart(2, '0')}`;
 }
+const MAX_XLSX_RICH_TEXT_CELL_CHARACTERS = 32767;
+const MAX_XLSX_RICH_TEXT_RUNS_PER_CELL = 512;
+const MAX_XLSX_RICH_TEXT_FONT_NAME_CHARACTERS = 128;
+const MAX_XLSX_RICH_TEXT_FONT_SIZE = 409;
+function normalizeXlsxRichTextEditSource(cell) {
+    if (cell?.f) return null;
+    if (cell) {
+        const rich = normalizeXlsxRichTextCell(cell);
+        if (rich) return rich;
+    }
+    const text = cell?.v;
+    if (void 0 !== text && ('string' != typeof text || text.length > MAX_XLSX_RICH_TEXT_CELL_CHARACTERS || !validXlsxRichText(text))) return null;
+    const value = text ?? '';
+    return {
+        runs: value ? [
+            xlsxRichTextBaseRun(cell, value)
+        ] : [],
+        text: value
+    };
+}
+function xlsxRichTextBaseRun(cell, text) {
+    const run = {
+        v: text
+    };
+    if (1 === Number(cell?.bl)) run.bl = 1;
+    if (1 === Number(cell?.it)) run.it = 1;
+    if (1 === Number(cell?.cl)) run.cl = 1;
+    const underline = Number(cell?.un);
+    if (Number.isSafeInteger(underline) && underline >= 1 && underline <= 4) run.un = underline;
+    if ('string' == typeof cell?.ff && cell.ff.trim() && cell.ff.trim().length <= MAX_XLSX_RICH_TEXT_FONT_NAME_CHARACTERS) run.ff = cell.ff.trim();
+    const size = Number(cell?.fs);
+    if (Number.isFinite(size) && size >= 1 && size <= MAX_XLSX_RICH_TEXT_FONT_SIZE) run.fs = size;
+    const color = normalizeXlsxRichTextColor(cell?.fc);
+    if (color) {
+        run.fc = color;
+        const origin = normalizeXlsxSemanticColorOrigin(xlsxCellStyleOrigin(cell ?? {})?.fontColor);
+        if (origin && xlsxSemanticColorMatchesValue(origin, color)) run.a3sXlsxColorOrigin = origin;
+    }
+    return run;
+}
+function normalizeXlsxRichTextCell(cell) {
+    if (cell.f || cell.ct?.t !== 'inlineStr' || !Array.isArray(cell.ct.s)) return null;
+    if (!cell.ct.s.length || cell.ct.s.length > MAX_XLSX_RICH_TEXT_RUNS_PER_CELL) return null;
+    const runs = [];
+    let characterCount = 0;
+    for (const candidate of cell.ct.s){
+        const run = normalizeXlsxRichTextRun(candidate);
+        if (!run) return null;
+        if (run.v) {
+            characterCount += run.v.length;
+            if (characterCount > MAX_XLSX_RICH_TEXT_CELL_CHARACTERS) return null;
+            runs.push(run);
+        }
+    }
+    const text = runs.map((run)=>run.v).join('');
+    return runs.length && text ? {
+        runs,
+        text
+    } : null;
+}
+function normalizeXlsxRichTextRun(value) {
+    if (!isRecord(value) || 'string' != typeof value.v || !validXlsxRichText(value.v)) return null;
+    const run = {
+        v: value.v
+    };
+    copyToggle(value, run, 'bl');
+    copyToggle(value, run, 'it');
+    copyToggle(value, run, 'cl');
+    if ('string' == typeof value.ff && value.ff.trim() && value.ff.trim().length <= MAX_XLSX_RICH_TEXT_FONT_NAME_CHARACTERS) run.ff = value.ff.trim();
+    if ('number' == typeof value.fs && Number.isFinite(value.fs) && value.fs >= 1 && value.fs <= MAX_XLSX_RICH_TEXT_FONT_SIZE) run.fs = value.fs;
+    const color = normalizeXlsxRichTextColor(value.fc);
+    if (color) run.fc = color;
+    const underline = Number(value.un);
+    if (Number.isSafeInteger(underline) && underline >= 0 && underline <= 4 && void 0 !== value.un) run.un = underline;
+    const colorOrigin = normalizeXlsxSemanticColorOrigin(value.a3sXlsxColorOrigin);
+    if (colorOrigin) run.a3sXlsxColorOrigin = colorOrigin;
+    return run;
+}
+function normalizeXlsxRichTextColor(value) {
+    const rgb = xlsxRgbColor(value);
+    return rgb ? `#${rgb.slice(-6).toLowerCase()}` : null;
+}
+function coalesceXlsxRichTextRuns(source) {
+    const result = [];
+    for (const run of source){
+        if (!run.v) continue;
+        const previous = result.at(-1);
+        if (previous && sameXlsxRichTextRunStyle(previous, run)) previous.v += run.v;
+        else result.push({
+            ...run
+        });
+    }
+    return result;
+}
+function sameXlsxRichTextRunStyle(left, right) {
+    return left.bl === right.bl && left.cl === right.cl && left.fc === right.fc && left.ff === right.ff && left.fs === right.fs && left.it === right.it && left.un === right.un && JSON.stringify(left.a3sXlsxColorOrigin) === JSON.stringify(right.a3sXlsxColorOrigin);
+}
+function validXlsxRichText(value) {
+    for(let index = 0; index < value.length; index += 1){
+        const code = value.charCodeAt(index);
+        if (0x09 !== code && 0x0a !== code && 0x0d !== code && (!(code >= 0x20) || !(code <= 0xd7ff)) && (!(code >= 0xe000) || !(code <= 0xfffd))) {
+            if (isHighSurrogate(code) && index + 1 < value.length && isLowSurrogate(value.charCodeAt(index + 1))) {
+                index += 1;
+                continue;
+            }
+            return false;
+        }
+    }
+    return true;
+}
+function isHighSurrogate(value) {
+    return value >= 0xd800 && value <= 0xdbff;
+}
+function isLowSurrogate(value) {
+    return value >= 0xdc00 && value <= 0xdfff;
+}
+function copyToggle(source, target, key) {
+    if (1 === Number(source[key])) target[key] = 1;
+    else if (0 === Number(source[key]) && void 0 !== source[key]) target[key] = 0;
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function reconcileSpreadsheetRichTextCellEdit(previous, current, formattedPaste) {
+    if (current.f) return current;
+    const source = formattedPaste ? normalizeXlsxRichTextEditSource(previous) : previous ? normalizeXlsxRichTextCell(previous) : null;
+    if (!source) return current;
+    const live = liveRichTextValue(current);
+    if (!live || '' === live.text) return current;
+    const replacement = richTextReplacement(source.text, live.text);
+    const sourceRuns = indexRichTextRuns(source);
+    const formattedPasteRuns = formattedPaste ? reconstructFormattedPasteRuns(source, sourceRuns, live.text, formattedPaste) : null;
+    const runs = formattedPasteRuns ?? (live.rich && live.text === source.text ? restoreSemanticColorOrigins(live.rich.runs, sourceRuns, replacement) : reconstructPlainTextRuns(sourceRuns, replacement));
+    const normalizedRuns = coalesceXlsxRichTextRuns(runs);
+    if (!normalizedRuns.length || normalizedRuns.length > 512 || normalizedRuns.map((run)=>run.v).join('') !== live.text) return current;
+    return spreadsheetRichTextCellWithRuns(previous, current, live.text, normalizedRuns);
+}
+function restoreSpreadsheetRichTextCellRuns(previous, current) {
+    if (!previous || current.f) return current;
+    const source = normalizeXlsxRichTextCell(previous);
+    const live = liveRichTextValue(current);
+    if (!source || !live || source.text !== live.text) return current;
+    return spreadsheetRichTextCellWithRuns(previous, current, source.text, source.runs);
+}
+function spreadsheetRichTextCellWithRuns(previous, current, text, runs) {
+    const next = {
+        ...current,
+        ct: {
+            ...previous?.ct,
+            ...current.ct,
+            s: runs.map((run)=>({
+                    ...run
+                })),
+            t: 'inlineStr'
+        },
+        v: text
+    };
+    delete next.f;
+    delete next.m;
+    return next;
+}
+function sameSpreadsheetRichTextCellText(previous, current) {
+    if (!previous || current.f) return false;
+    const source = normalizeXlsxRichTextCell(previous);
+    const live = liveRichTextValue(current);
+    return Boolean(source && live && source.text === live.text);
+}
+function liveRichTextValue(cell) {
+    const rich = normalizeXlsxRichTextCell(cell);
+    if ('string' == typeof cell.v && cell.v !== rich?.text) return validBoundedText(cell.v) ? {
+        rich: null,
+        text: cell.v
+    } : null;
+    if (rich) return {
+        rich,
+        text: rich.text
+    };
+    return 'string' == typeof cell.v && validBoundedText(cell.v) ? {
+        rich: null,
+        text: cell.v
+    } : null;
+}
+function validBoundedText(value) {
+    return value.length <= 32767 && validXlsxRichText(value);
+}
+function richTextReplacement(previous, current) {
+    let left = 0;
+    let right = 0;
+    while(left < previous.length && left < current.length && previous[left] === current[left])left += 1;
+    if (left > 0 && isHighSurrogate(previous.charCodeAt(left - 1))) left -= 1;
+    while(right + left < previous.length && right + left < current.length && previous[previous.length - right - 1] === current[current.length - right - 1])right += 1;
+    if (right > 0 && isLowSurrogate(previous.charCodeAt(previous.length - right))) right -= 1;
+    return {
+        index: left,
+        insert: current.slice(left, current.length - right),
+        remove: previous.length - left - right
+    };
+}
+function indexRichTextRuns(source) {
+    let offset = 0;
+    return source.runs.map((run)=>{
+        const indexed = {
+            end: offset + run.v.length,
+            run,
+            start: offset
+        };
+        offset = indexed.end;
+        return indexed;
+    });
+}
+function reconstructPlainTextRuns(source, replacement) {
+    const runs = [];
+    appendSourceRange(runs, source, 0, replacement.index);
+    if (replacement.insert) {
+        const inherited = insertionSourceRun(source, replacement);
+        if (inherited) runs.push({
+            ...inherited.run,
+            v: replacement.insert
+        });
+    }
+    const sourceLength = source.at(-1)?.end ?? 0;
+    appendSourceRange(runs, source, replacement.index + replacement.remove, sourceLength);
+    return runs;
+}
+function reconstructFormattedPasteRuns(source, sourceRuns, currentText, intent) {
+    if (!validRichTextPasteSelection(source.text, intent.start, intent.end) || 'string' != typeof intent.text || !intent.text || intent.text.length > 32767 || !validXlsxRichText(intent.text) || !Array.isArray(intent.runs) || !intent.runs.length || intent.runs.length > 512) return null;
+    const pastedRuns = [];
+    for (const candidate of intent.runs){
+        const run = normalizeXlsxRichTextRun(candidate);
+        if (!run) return null;
+        if (run.v) pastedRuns.push(run);
+    }
+    if (!pastedRuns.length || pastedRuns.map((run)=>run.v).join('') !== intent.text) return null;
+    const expectedText = source.text.slice(0, intent.start) + intent.text + source.text.slice(intent.end);
+    if (expectedText !== currentText || expectedText.length > 32767 || !validXlsxRichText(expectedText)) return null;
+    const runs = [];
+    appendSourceRange(runs, sourceRuns, 0, intent.start);
+    runs.push(...pastedRuns);
+    appendSourceRange(runs, sourceRuns, intent.end, source.text.length);
+    const normalized = coalesceXlsxRichTextRuns(runs);
+    return normalized.length > 0 && normalized.length <= 512 ? normalized : null;
+}
+function validRichTextPasteSelection(text, start, end) {
+    return Boolean(Number.isInteger(start) && Number.isInteger(end) && start >= 0 && start <= end && end <= text.length && !splitsSurrogatePair(text, start) && !splitsSurrogatePair(text, end));
+}
+function splitsSurrogatePair(text, offset) {
+    if (offset <= 0 || offset >= text.length) return false;
+    return isHighSurrogate(text.charCodeAt(offset - 1)) && isLowSurrogate(text.charCodeAt(offset));
+}
+function appendSourceRange(target, source, start, end) {
+    if (start >= end) return;
+    for (const indexed of source){
+        const overlapStart = Math.max(start, indexed.start);
+        const overlapEnd = Math.min(end, indexed.end);
+        if (!(overlapStart >= overlapEnd)) target.push({
+            ...indexed.run,
+            v: indexed.run.v.slice(overlapStart - indexed.start, overlapEnd - indexed.start)
+        });
+    }
+}
+function restoreSemanticColorOrigins(current, source, replacement) {
+    const runs = [];
+    let absoluteOffset = 0;
+    for (const currentRun of current){
+        let localOffset = 0;
+        while(localOffset < currentRun.v.length){
+            const width = codePointWidth(currentRun.v, localOffset);
+            const origin = semanticOriginAt(source, replacement, absoluteOffset + localOffset);
+            const next = {
+                ...currentRun,
+                v: currentRun.v.slice(localOffset, localOffset + width)
+            };
+            delete next.a3sXlsxColorOrigin;
+            if (origin && currentRun.fc && xlsxSemanticColorMatchesValue(origin, currentRun.fc)) next.a3sXlsxColorOrigin = origin;
+            runs.push(next);
+            localOffset += width;
+        }
+        absoluteOffset += currentRun.v.length;
+    }
+    return runs;
+}
+function semanticOriginAt(source, replacement, currentOffset) {
+    let indexed;
+    indexed = currentOffset < replacement.index ? sourceRunAt(source, currentOffset) : currentOffset >= replacement.index + replacement.insert.length ? sourceRunAt(source, currentOffset - replacement.insert.length + replacement.remove) : insertionSourceRun(source, replacement);
+    return normalizeXlsxSemanticColorOrigin(indexed?.run.a3sXlsxColorOrigin);
+}
+function insertionSourceRun(source, replacement) {
+    const sourceLength = source.at(-1)?.end ?? 0;
+    if (!sourceLength) return;
+    if (replacement.remove > 0 && replacement.index < sourceLength) return sourceRunAt(source, replacement.index);
+    if (replacement.index > 0) return sourceRunAt(source, replacement.index - 1);
+    return sourceRunAt(source, 0);
+}
+function sourceRunAt(source, offset) {
+    let left = 0;
+    let right = source.length - 1;
+    while(left <= right){
+        const middle = left + Math.floor((right - left) / 2);
+        const indexed = source[middle];
+        if (!indexed) break;
+        if (offset < indexed.start) right = middle - 1;
+        else {
+            if (!(offset >= indexed.end)) return indexed;
+            left = middle + 1;
+        }
+    }
+}
+function codePointWidth(value, offset) {
+    return isHighSurrogate(value.charCodeAt(offset)) && isLowSurrogate(value.charCodeAt(offset + 1)) ? 2 : 1;
+}
+const spreadsheetFontSizes = [
+    9,
+    10,
+    11,
+    12,
+    14,
+    16,
+    18,
+    20,
+    22,
+    24,
+    28,
+    36,
+    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 captureSpreadsheetRichTextDomSelection({ expandedOnly = false, root, target }) {
+    const selection = window.getSelection();
+    if (!root || !selection || 1 !== selection.rangeCount) return null;
+    const range = selection.getRangeAt(0);
+    if (expandedOnly && range.collapsed) return null;
+    const targetNode = target instanceof Node ? target : null;
+    const editor = spreadsheetRichTextEditor(targetNode ?? range.commonAncestorContainer);
+    if (!editor || !root.contains(editor) || !editorContainsRange(editor, range)) return null;
+    const start = spreadsheetTextOffsetAtPoint(editor, range.startContainer, range.startOffset);
+    const end = spreadsheetTextOffsetAtPoint(editor, range.endContainer, range.endOffset);
+    return null === start || null === end || start > end ? null : {
+        editor,
+        end,
+        start
+    };
+}
+function spreadsheetRichTextEditor(node) {
+    const element = node instanceof Element ? node : node.parentElement;
+    const editor = element?.closest('.luckysheet-cell-input, .fortune-fx-input');
+    return editor?.isContentEditable || editor?.getAttribute('contenteditable') === 'true' ? editor : null;
+}
+function editorContainsRange(editor, range) {
+    return (range.startContainer === editor || editor.contains(range.startContainer)) && (range.endContainer === editor || editor.contains(range.endContainer));
+}
+function spreadsheetTextOffsetAtPoint(editor, node, offset) {
+    try {
+        const prefix = document.createRange();
+        prefix.selectNodeContents(editor);
+        prefix.setEnd(node, offset);
+        return prefix.toString().length;
+    } catch  {
+        return null;
+    }
+}
+const MAX_SPREADSHEET_RICH_TEXT_CLIPBOARD_HTML_CHARACTERS = 256000;
+const pendingPastes = new WeakMap();
+const ignoredClipboardElements = new Set([
+    'HEAD',
+    'META',
+    'NOSCRIPT',
+    'SCRIPT',
+    'STYLE',
+    'TITLE'
+]);
+const blockClipboardElements = new Set([
+    'ADDRESS',
+    'BLOCKQUOTE',
+    'DIV',
+    'H1',
+    'H2',
+    'H3',
+    'H4',
+    'H5',
+    'H6',
+    'LI',
+    'P',
+    'PRE'
+]);
+function parseSpreadsheetRichTextClipboard(html, plainText) {
+    const text = normalizeClipboardText(plainText);
+    if (!html || html.length > MAX_SPREADSHEET_RICH_TEXT_CLIPBOARD_HTML_CHARACTERS || !text || text.length > 32767 || !validXlsxRichText(text)) return null;
+    const template = document.createElement('template');
+    template.innerHTML = html;
+    const runs = [];
+    const state = {
+        characterCount: 0,
+        invalid: false
+    };
+    for (const child of template.content.childNodes){
+        collectClipboardRuns(child, {}, runs, state);
+        if (state.invalid) return null;
+    }
+    trimTrailingClipboardNewline(runs, text);
+    const normalized = coalesceXlsxRichTextRuns(runs);
+    if (!normalized.length || normalized.length > 512 || normalized.map((run)=>run.v).join('') !== text || !normalized.some(spreadsheetRichTextRunHasFormatting)) return null;
+    return {
+        runs: normalized,
+        text
+    };
+}
+function captureSpreadsheetRichTextPaste({ clipboardData, content, root, selection, sheetId, target }) {
+    const domSelection = captureSpreadsheetRichTextDomSelection({
+        root,
+        target
+    });
+    const sheet = content.sheets.find((candidate)=>candidate.id === sheetId);
+    if (!domSelection || !sheet || !selection) return false;
+    const row = focusedAxisIndex(selection.row_focus, selection.row);
+    const column = focusedAxisIndex(selection.column_focus, selection.column);
+    const cell = spreadsheetCellAt(sheet, row, column);
+    const source = normalizeXlsxRichTextEditSource(cell);
+    const key = spreadsheetRichTextPasteKey(row, column);
+    if (!source || domSelection.editor.textContent !== source.text || domSelection.end > source.text.length) {
+        clearPendingPaste(sheet, key);
+        return false;
+    }
+    const parsed = parseSpreadsheetRichTextClipboard(clipboardData.getData('text/html'), clipboardData.getData('text/plain'));
+    if (!parsed) {
+        clearPendingPaste(sheet, key);
+        return false;
+    }
+    stageSpreadsheetRichTextPaste(sheet, row, column, source.text, {
+        end: domSelection.end,
+        runs: parsed.runs,
+        start: domSelection.start,
+        text: parsed.text
+    });
+    return true;
+}
+function stageSpreadsheetRichTextPaste(sheet, row, column, sourceText, intent) {
+    if (!validCoordinate(row) || !validCoordinate(column)) return;
+    const key = spreadsheetRichTextPasteKey(row, column);
+    const entries = pendingPastes.get(sheet) ?? new Map();
+    pendingPastes.set(sheet, entries);
+    entries.set(key, {
+        intent: {
+            ...intent,
+            runs: intent.runs.map((run)=>({
+                    ...run
+                }))
+        },
+        sourceText
+    });
+}
+function takeSpreadsheetRichTextPaste(sheet, row, column, current) {
+    const intent = peekSpreadsheetRichTextPaste(sheet, row, column, current);
+    if (intent) consumeSpreadsheetRichTextPaste(sheet, row, column);
+    return intent;
+}
+function peekSpreadsheetRichTextPaste(sheet, row, column, current) {
+    const entries = pendingPastes.get(sheet);
+    const key = spreadsheetRichTextPasteKey(row, column);
+    const pending = entries?.get(key);
+    if (!entries || !pending) return;
+    const currentText = spreadsheetRichTextCellText(current);
+    if (currentText === pending.sourceText) return;
+    return null === currentText ? void 0 : pending.intent;
+}
+function consumeSpreadsheetRichTextPaste(sheet, row, column) {
+    clearPendingPaste(sheet, spreadsheetRichTextPasteKey(row, column));
+}
+function collectClipboardRuns(node, inherited, runs, state) {
+    if (state.invalid) return;
+    if (node.nodeType === Node.TEXT_NODE) return void appendClipboardText(runs, inherited, node.textContent ?? '', state);
+    if (!(node instanceof HTMLElement) || ignoredClipboardElements.has(node.tagName)) return;
+    const style = spreadsheetClipboardElementStyle(node, inherited);
+    if ('BR' === node.tagName) return void appendClipboardText(runs, style, '\n', state);
+    for (const child of node.childNodes){
+        collectClipboardRuns(child, style, runs, state);
+        if (state.invalid) return;
+    }
+    if (blockClipboardElements.has(node.tagName) && hasFollowingClipboardContent(node)) appendClipboardText(runs, style, '\n', state);
+}
+function appendClipboardText(runs, style, source, state) {
+    const value = normalizeClipboardText(source);
+    if (!value) return;
+    state.characterCount += value.length;
+    if (state.characterCount > 32767 || !validXlsxRichText(value)) {
+        state.invalid = true;
+        return;
+    }
+    const run = {
+        ...style,
+        v: value
+    };
+    const previous = runs.at(-1);
+    if (previous && sameXlsxRichTextRunStyle(previous, run)) previous.v += value;
+    else runs.push(run);
+    if (runs.length > 512) state.invalid = true;
+}
+function spreadsheetClipboardElementStyle(element, inherited) {
+    const style = {
+        ...inherited
+    };
+    if (element.matches('b, strong')) style.bl = 1;
+    if (element.matches('i, em')) style.it = 1;
+    if (element.matches('s, strike, del')) style.cl = 1;
+    if (element.matches('u')) style.un = 1;
+    const declarations = cssDeclarations(element.getAttribute('style'));
+    applyFontWeight(style, declarations.get('font-weight'));
+    applyToggle(style, 'it', declarations.get('font-style'), 'italic');
+    applyTextDecoration(style, declarations);
+    applyFontFamily(style, declarations.get('font-family'));
+    applyFontSize(style, declarations.get('font-size'));
+    applyFontColor(style, declarations.get('color'));
+    applyFortuneToggle(style, 'cl', declarations.get('lucky-strike'));
+    applyFortuneUnderline(style, declarations.get('lucky-underline'));
+    if (declarations.get('border-bottom')?.trim().toLowerCase() !== 'none') {
+        if (declarations.has('border-bottom')) style.un = 1;
+    }
+    if ('FONT' === element.tagName) {
+        applyFontFamily(style, element.getAttribute('face') ?? void 0);
+        applyFontColor(style, element.getAttribute('color') ?? void 0);
+        applyHtmlFontSize(style, element.getAttribute('size'));
+    }
+    return style;
+}
+function cssDeclarations(value) {
+    const declarations = new Map();
+    for (const candidate of value?.split(';') ?? []){
+        const separator = candidate.indexOf(':');
+        if (separator <= 0) continue;
+        const key = candidate.slice(0, separator).trim().toLowerCase();
+        const declaration = candidate.slice(separator + 1).trim();
+        if (key && declaration) declarations.set(key, declaration);
+    }
+    return declarations;
+}
+function applyFontWeight(style, value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized) return;
+    if ('bold' === normalized || 'bolder' === normalized) style.bl = 1;
+    else if ('normal' === normalized || 'lighter' === normalized) style.bl = 0;
+    else if (/^\d+$/.test(normalized)) style.bl = Number(normalized) >= 600 ? 1 : 0;
+}
+function applyToggle(style, key, value, enabled) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized) return;
+    style[key] = normalized === enabled || 'oblique' === normalized ? 1 : 0;
+}
+function applyTextDecoration(style, declarations) {
+    const value = declarations.get('text-decoration-line') ?? declarations.get('text-decoration');
+    const normalized = value?.toLowerCase();
+    if (!normalized) return;
+    if (normalized.includes('none')) {
+        style.cl = 0;
+        style.un = 0;
+        return;
+    }
+    if (normalized.includes('line-through')) style.cl = 1;
+    if (normalized.includes('underline')) style.un = 'double' === declarations.get('text-decoration-style') ? 2 : 1;
+}
+function applyFontFamily(style, value) {
+    const family = value?.split(',')[0]?.trim().replace(/^(['"])(.*)\1$/, '$2');
+    if (family && family.length <= 128) style.ff = family;
+}
+function applyFontSize(style, value) {
+    const match = /^([\d.]+)\s*(pt|px)$/i.exec(value?.trim() ?? '');
+    if (!match) return;
+    const number = Number(match[1]);
+    const size = match[2]?.toLowerCase() === 'px' ? 0.75 * number : number;
+    if (Number.isFinite(size) && size >= 1 && size <= 409) style.fs = Math.round(100 * size) / 100;
+}
+function applyFontColor(style, value) {
+    const color = normalizeCssColor(value);
+    if (color && 'transparent' !== color) style.fc = color;
+}
+function applyFortuneToggle(style, key, value) {
+    const toggle = Number(value);
+    if (Number.isSafeInteger(toggle) && (0 === toggle || 1 === toggle)) style[key] = toggle;
+}
+function applyFortuneUnderline(style, value) {
+    const underline = Number(value);
+    if (Number.isSafeInteger(underline) && underline >= 0 && underline <= 4) style.un = underline;
+}
+function applyHtmlFontSize(style, value) {
+    const index = Number(value);
+    const size = [
+        0,
+        8,
+        10,
+        12,
+        14,
+        18,
+        24,
+        36
+    ][index];
+    if (size) style.fs = size;
+}
+function spreadsheetRichTextRunHasFormatting(run) {
+    return [
+        'bl',
+        'cl',
+        'fc',
+        'ff',
+        'fs',
+        'it',
+        'un'
+    ].some((key)=>void 0 !== run[key]);
+}
+function trimTrailingClipboardNewline(runs, expectedText) {
+    const actual = runs.map((run)=>run.v).join('');
+    if (!actual.endsWith('\n') || expectedText.endsWith('\n')) return;
+    const last = runs.at(-1);
+    if (!last) return;
+    last.v = last.v.slice(0, -1);
+    if (!last.v) runs.pop();
+}
+function hasFollowingClipboardContent(element) {
+    let sibling = element.nextSibling;
+    while(sibling){
+        if (sibling.nodeType === Node.TEXT_NODE) {
+            if (sibling.textContent) return true;
+        } else if (sibling instanceof HTMLElement && !ignoredClipboardElements.has(sibling.tagName)) return true;
+        sibling = sibling.nextSibling;
+    }
+    return false;
+}
+function spreadsheetRichTextCellText(cell) {
+    const rich = normalizeXlsxRichTextCell(cell);
+    if ('string' == typeof cell.v && cell.v !== rich?.text) return cell.v;
+    return rich?.text ?? ('string' == typeof cell.v ? cell.v : null);
+}
+function spreadsheetCellAt(sheet, row, column) {
+    return sheet.data?.[row]?.[column] ?? sheet.celldata?.find((candidate)=>candidate.r === row && candidate.c === column)?.v ?? null;
+}
+function focusedAxisIndex(value, axis) {
+    const minimum = spreadsheet_rich_text_paste_finiteIndex(axis[0], 0);
+    const maximum = spreadsheet_rich_text_paste_finiteIndex(axis[1], minimum);
+    const focus = spreadsheet_rich_text_paste_finiteIndex(value, minimum);
+    return Math.min(Math.max(minimum, maximum), Math.max(Math.min(minimum, maximum), focus));
+}
+function spreadsheet_rich_text_paste_finiteIndex(value, fallback) {
+    return 'number' == typeof value && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : fallback;
+}
+function normalizeClipboardText(value) {
+    return value.replace(/\r\n?/g, '\n').replace(/\u00a0/g, ' ');
+}
+function clearPendingPaste(sheet, key) {
+    const entries = pendingPastes.get(sheet);
+    entries?.delete(key);
+    if (entries && !entries.size) pendingPastes.delete(sheet);
+}
+function spreadsheetRichTextPasteKey(row, column) {
+    return `${row}:${column}`;
+}
+function validCoordinate(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+const MAXIMUM_INCREMENTAL_SPREADSHEET_OPERATIONS = 10000;
+function spreadsheetCellOperationKey(row, column) {
+    return `${row}:${column}`;
+}
+function spreadsheetCellOperationCoordinates(operations) {
+    if (operations.length > MAXIMUM_INCREMENTAL_SPREADSHEET_OPERATIONS) return null;
+    const coordinatesBySheet = new Map();
+    for (const operation of operations){
+        if ('insertRowCol' === operation.op || 'deleteRowCol' === operation.op || 'addSheet' === operation.op || 'deleteSheet' === operation.op || 0 === operation.path.length || !operation.id) return null;
+        const root = operation.path[0];
+        if ('id' === root || 'celldata' === root) return null;
+        if ('data' !== root) continue;
+        const row = operation.path[1];
+        const column = operation.path[2];
+        if (operation.path.length < 3 || !isSpreadsheetCoordinate(row) || !isSpreadsheetCoordinate(column)) return null;
+        const coordinates = coordinatesBySheet.get(operation.id) ?? new Map();
+        coordinatesBySheet.set(operation.id, coordinates);
+        coordinates.set(spreadsheetCellOperationKey(row, column), {
+            column,
+            row
+        });
+    }
+    return coordinatesBySheet;
+}
+function projectSpreadsheetSheetsFromFortuneOperations(sheets, sourceSheets, operations) {
+    if (0 === operations.length || sheets.length !== sourceSheets.length) return null;
+    const changedSheets = spreadsheetSheetsById(sheets);
+    const controlledSheets = spreadsheetSheetsById(sourceSheets);
+    if (!changedSheets || !controlledSheets) return null;
+    if (changedSheets.size !== sheets.length || controlledSheets.size !== sourceSheets.length) return null;
+    const coordinatesBySheet = spreadsheetCellOperationCoordinates(operations);
+    if (!coordinatesBySheet) return null;
+    for (const operation of operations)if (!operation.id || !changedSheets.has(operation.id) || !controlledSheets.has(operation.id)) return null;
+    let affectedCellCount = 0;
+    const projectedSheets = [];
+    const pendingRichTextPastes = [];
+    for (const sheet of sheets){
+        const id = sheet.id;
+        if (!id) return null;
+        const source = controlledSheets.get(id);
+        if (!source) return null;
+        const coordinates = coordinatesBySheet.get(id);
+        const { celldata: _cellData, data: _data, ...metadata } = sheet;
+        if (!coordinates?.size) {
+            projectedSheets.push(void 0 !== source.data ? {
+                ...metadata,
+                data: source.data
+            } : {
+                ...metadata,
+                celldata: source.celldata ?? []
+            });
+            continue;
+        }
+        if (void 0 === source.data || void 0 === sheet.data || !spreadsheetMatrixProfile(source.data)?.fortuneReady) return null;
+        const projection = projectSpreadsheetMatrixCells(sheet, source, coordinates.values(), pendingRichTextPastes);
+        if (!projection) return null;
+        affectedCellCount += projection.affectedCellCount;
+        projectedSheets.push({
+            ...metadata,
+            data: projection.data
+        });
+    }
+    for (const pending of pendingRichTextPastes)consumeSpreadsheetRichTextPaste(pending.sheet, pending.row, pending.column);
+    return {
+        affectedCellCount,
+        sheets: projectedSheets
+    };
+}
+function projectSpreadsheetMatrixCells(changed, source, coordinates, pendingRichTextPastes) {
+    if (!changed.data || !source.data) return null;
+    const data = source.data.slice();
+    data.length = Math.max(data.length, changed.data.length, positiveSpreadsheetDimension(changed.row));
+    const mutableRows = new Map();
+    const profileChanges = [];
+    for (const { column, row } of coordinates){
+        const changedRow = changed.data[row];
+        const sourceRow = source.data[row];
+        const currentCell = changedRow?.[column];
+        const formattedPaste = currentCell ? peekSpreadsheetRichTextPaste(source, row, column, currentCell) : void 0;
+        const nextCell = null == currentCell ? currentCell : cloneControlledSpreadsheetCell(currentCell, sourceRow?.[column], formattedPaste);
+        if (formattedPaste) pendingRichTextPastes.push({
+            column,
+            row,
+            sheet: source
+        });
+        let nextRow = mutableRows.get(row);
+        if (!nextRow) {
+            nextRow = sourceRow?.slice() ?? [];
+            nextRow.length = Math.max(nextRow.length, changedRow?.length ?? 0, positiveSpreadsheetDimension(changed.column));
+            mutableRows.set(row, nextRow);
+            data[row] = nextRow;
+        }
+        if (null == nextCell) delete nextRow[column];
+        else nextRow[column] = nextCell;
+        profileChanges.push({
+            column,
+            current: nextCell,
+            previous: sourceRow?.[column],
+            row
+        });
+    }
+    if (!registerDerivedSpreadsheetMatrix(data, source.data, profileChanges)) return null;
+    return {
+        affectedCellCount: profileChanges.length,
+        data
+    };
+}
+function cloneControlledSpreadsheetCell(cell, previous, formattedPaste) {
+    return freezeImportedSpreadsheetCell(structuredClone(reconcileSpreadsheetRichTextCellEdit(previous, cell, formattedPaste)));
+}
+function spreadsheetSheetsById(sheets) {
+    const byId = new Map();
+    for (const sheet of sheets){
+        if (!sheet.id || byId.has(sheet.id)) return null;
+        byId.set(sheet.id, sheet);
+    }
+    return byId;
+}
+function isSpreadsheetCoordinate(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function positiveSpreadsheetDimension(value) {
+    return 'number' == typeof value && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function normalizeSpreadsheetCellRange(value) {
+    const row = normalizeSpreadsheetCellRangeAxis(value.row);
+    const column = normalizeSpreadsheetCellRangeAxis(value.column);
+    return row && column ? {
+        row,
+        column
+    } : null;
+}
+function parseSpreadsheetCellRange(value) {
+    if (!spreadsheet_cell_range_isRecord(value)) return null;
+    const row = normalizeSpreadsheetCellRangeAxis(value.row);
+    const column = normalizeSpreadsheetCellRangeAxis(value.column);
+    return row && column ? {
+        row,
+        column
+    } : null;
+}
+function subtractSpreadsheetCellRange(source, removed) {
+    const top = Math.max(source.row[0], removed.row[0]);
+    const bottom = Math.min(source.row[1], removed.row[1]);
+    const left = Math.max(source.column[0], removed.column[0]);
+    const right = Math.min(source.column[1], removed.column[1]);
+    if (top > bottom || left > right) return [
+        source
+    ];
+    const remaining = [];
+    if (source.row[0] < top) remaining.push({
+        row: [
+            source.row[0],
+            top - 1
+        ],
+        column: [
+            ...source.column
+        ]
+    });
+    if (bottom < source.row[1]) remaining.push({
+        row: [
+            bottom + 1,
+            source.row[1]
+        ],
+        column: [
+            ...source.column
+        ]
+    });
+    if (source.column[0] < left) remaining.push({
+        row: [
+            top,
+            bottom
+        ],
+        column: [
+            source.column[0],
+            left - 1
+        ]
+    });
+    if (right < source.column[1]) remaining.push({
+        row: [
+            top,
+            bottom
+        ],
+        column: [
+            right + 1,
+            source.column[1]
+        ]
+    });
+    return remaining;
+}
+function spreadsheetCellRangesIntersect(left, right) {
+    return !(left.row[1] < right.row[0] || right.row[1] < left.row[0] || left.column[1] < right.column[0] || right.column[1] < left.column[0]);
+}
+function spreadsheetCellRangesEqual(left, right) {
+    const normalizedLeft = normalizeSpreadsheetCellRange(left);
+    const normalizedRight = normalizeSpreadsheetCellRange(right);
+    return Boolean(normalizedLeft && normalizedRight && normalizedLeft.row[0] === normalizedRight.row[0] && normalizedLeft.row[1] === normalizedRight.row[1] && normalizedLeft.column[0] === normalizedRight.column[0] && normalizedLeft.column[1] === normalizedRight.column[1]);
+}
+function spreadsheetCellRangeContains(range, row, column) {
+    return row >= range.row[0] && row <= range.row[1] && column >= range.column[0] && column <= range.column[1];
+}
+function spreadsheetCellRangeArea(range) {
+    return (range.row[1] - range.row[0] + 1) * (range.column[1] - range.column[0] + 1);
+}
+function normalizeSpreadsheetCellRangeAxis(value) {
+    if (!Array.isArray(value)) return null;
+    const first = finiteSpreadsheetCellIndex(value[0]);
+    const second = finiteSpreadsheetCellIndex(value[1]);
+    if (null === first || null === second) return null;
+    return [
+        Math.min(first, second),
+        Math.max(first, second)
+    ];
+}
+function finiteSpreadsheetCellIndex(value) {
+    return 'number' == typeof value && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
+}
+function spreadsheet_cell_range_isRecord(value) {
+    return Boolean(value && 'object' == typeof value && !Array.isArray(value));
+}
+function spreadsheetCurrentRegion(sheet, seed) {
+    const range = normalizeSpreadsheetCellRange(seed);
+    if (!range) return null;
+    const cells = spreadsheetSheetCellReader(sheet);
+    const bounds = spreadsheetCurrentRegionUsedBounds(sheet);
+    let startRow = range.row[0];
+    let endRow = range.row[1];
+    let startColumn = range.column[0];
+    let endColumn = range.column[1];
+    if (startRow > bounds.lastRow || startColumn > bounds.lastColumn || !spreadsheetCellHasContent(cells(startRow, startColumn))) return null;
+    let changed = true;
+    while(changed){
+        changed = false;
+        while(startColumn > 0 && spreadsheetCurrentRegionColumnHasContent(cells, startColumn - 1, startRow, endRow)){
+            startColumn -= 1;
+            changed = true;
+        }
+        while(endColumn < bounds.lastColumn && spreadsheetCurrentRegionColumnHasContent(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 spreadsheetRowHasContent(cellAt, row, startColumn, endColumn) {
+    for(let column = startColumn; column <= endColumn; column += 1)if (spreadsheetCellHasContent(cellAt(row, column))) return true;
+    return false;
+}
+function spreadsheetCurrentRegionColumnHasContent(cellAt, column, startRow, endRow) {
+    for(let row = startRow; row <= endRow; row += 1)if (spreadsheetCellHasContent(cellAt(row, column))) return true;
+    return false;
+}
+function spreadsheetCellHasContent(cell) {
+    if (!cell) return false;
+    return [
+        cell.v,
+        cell.m,
+        cell.f
+    ].some((value)=>null != value && '' !== value);
+}
+function spreadsheetSheetCellReader(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 spreadsheetCurrentRegionUsedBounds(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 parseSpreadsheetConditionalColor(value) {
+    const hexadecimal = /^#?([0-9a-f]{6})$/i.exec(value.trim());
+    if (hexadecimal) return {
+        red: Number.parseInt(hexadecimal[1].slice(0, 2), 16),
+        green: Number.parseInt(hexadecimal[1].slice(2, 4), 16),
+        blue: Number.parseInt(hexadecimal[1].slice(4, 6), 16)
+    };
+    const rgb = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i.exec(value);
+    if (!rgb) return null;
+    return {
+        red: boundedColorChannel(rgb[1]),
+        green: boundedColorChannel(rgb[2]),
+        blue: boundedColorChannel(rgb[3])
+    };
+}
+function interpolateSpreadsheetConditionalColor(start, end, amount) {
+    return {
+        red: Math.round(start.red + (end.red - start.red) * amount),
+        green: Math.round(start.green + (end.green - start.green) * amount),
+        blue: Math.round(start.blue + (end.blue - start.blue) * amount)
+    };
+}
+function spreadsheetConditionalCssColor(color) {
+    return `rgb(${color.red}, ${color.green}, ${color.blue})`;
+}
+function spreadsheetConditionalRatio(value, minimum, maximum) {
+    if (maximum === minimum) return 0;
+    return Math.max(0, Math.min(1, (value - minimum) / (maximum - minimum)));
+}
+function boundedColorChannel(value) {
+    return Math.max(0, Math.min(255, Number(value)));
+}
+function spreadsheetConditionalDataBar(color, value, minimum, maximum, minLength, maxLength, showValue) {
+    if (minimum < 0 && maximum > 0) {
+        const axis = -minimum / (maximum - minimum) * 100;
+        const ratio = value < 0 ? Math.abs(value / minimum) : value > 0 ? value / maximum : 0;
+        const width = 0 === value ? 0 : displayLength(ratio, minLength, maxLength) * (value < 0 ? axis / 100 : (100 - axis) / 100);
+        return {
+            color,
+            startPercent: value < 0 ? axis - width : axis,
+            widthPercent: width,
+            axisPercent: axis,
+            showValue
+        };
+    }
+    if (maximum <= 0) {
+        const ratio = minimum === maximum ? 0 === value ? 0 : 1 : Math.max(0, Math.min(1, (maximum - value) / (maximum - minimum)));
+        const width = 0 === value ? 0 : displayLength(ratio, minLength, maxLength);
+        return {
+            color,
+            startPercent: 100 - width,
+            widthPercent: width,
+            axisPercent: 100,
+            showValue
+        };
+    }
+    const ratio = minimum === maximum ? 0 === value ? 0 : 1 : Math.max(0, Math.min(1, (value - minimum) / (maximum - minimum)));
+    const width = 0 === value ? 0 : displayLength(ratio, minLength, maxLength);
+    return {
+        color,
+        startPercent: 0,
+        widthPercent: width,
+        axisPercent: 0,
+        showValue
+    };
+}
+function displayLength(valueRatio, minLength, maxLength) {
+    const normalized = Math.max(0, Math.min(1, valueRatio));
+    return minLength + (maxLength - minLength) * normalized;
+}
+const MAX_SPREADSHEET_LOCAL_FORMULA_LENGTH = 255;
+const MAX_SPREADSHEET_LOCAL_FORMULA_REFERENCED_CELLS = 1024;
+const MAX_SHEET_ROW = 1048576;
+const MAX_SHEET_COLUMN = 16384;
+const LOCAL_FORMULA_FUNCTIONS = new Set(SUPPORTED_FORMULAS.map((name)=>name.toUpperCase()));
+function evaluateSpreadsheetLocalFormula(formula, options) {
+    const source = formula.trim().replace(/^=/, '').trim();
+    if (!source) return unsupportedLocalFormula('公式为空。');
+    if (Array.from(source).length > MAX_SPREADSHEET_LOCAL_FORMULA_LENGTH) return unsupportedLocalFormula('公式超过 255 个字符。');
+    const currentSheet = options.sheets.find((candidate)=>candidate.id === options.sheetId);
+    if (!currentSheet) return unsupportedLocalFormula('找不到公式所在的工作表。');
+    const evaluator = new SpreadsheetLocalFormulaEvaluator(options, currentSheet);
+    return evaluator.evaluate(source);
+}
+function spreadsheetLocalFormulaBoolean(value) {
+    if ('boolean' == typeof value) return value;
+    if ('number' == typeof value) return Number.isFinite(value) && 0 !== value;
+    return 'string' == typeof value && 'TRUE' === value.trim().toUpperCase();
+}
+class SpreadsheetLocalFormulaEvaluator {
+    options;
+    currentSheet;
+    sheetsByName = new Map();
+    anchor;
+    referencedCells = 0;
+    unsupportedMessage;
+    celldataBySheet = new Map();
+    constructor(options, currentSheet){
+        this.options = options;
+        this.currentSheet = currentSheet;
+        this.anchor = {
+            row: options.anchorRow ?? options.row,
+            column: options.anchorColumn ?? options.column
+        };
+        for (const sheet of options.sheets)this.sheetsByName.set(sheet.name.trim().toLocaleLowerCase(), sheet);
+    }
+    evaluate(formula) {
+        const parser = new Parser();
+        parser.setFunction('ROW', (parameters)=>parameters.length ? null : this.options.row + 1).setFunction('COLUMN', (parameters)=>parameters.length ? null : this.options.column + 1);
+        let unsupportedFunction;
+        parser.on('callFunction', (name)=>{
+            const normalized = name.toUpperCase();
+            if (!LOCAL_FORMULA_FUNCTIONS.has(normalized)) unsupportedFunction ??= normalized;
+        });
+        parser.on('callCellValue', (coordinate, _parserOptions, done)=>{
+            const resolved = this.resolveCoordinate(this.currentSheet, coordinate);
+            if (!resolved) return void done(null);
+            done(this.readCell(resolved));
+        });
+        parser.on('callRangeValue', (start, end, _parserOptions, done)=>{
+            done(this.readRange(start, end));
+        });
+        const parsed = parser.parse(normalizeFormulaForFortuneParser(formula), {
+            sheetId: this.currentSheet.id
+        });
+        if (unsupportedFunction) return unsupportedLocalFormula(`公式函数“${unsupportedFunction}”无法在浏览器本地求值。`);
+        if (this.unsupportedMessage) return unsupportedLocalFormula(this.unsupportedMessage);
+        if (parsed.error || void 0 === parsed.result) return unsupportedLocalFormula('公式无法求值，请检查函数、引用和括号。');
+        return {
+            supported: true,
+            value: parsed.result
+        };
+    }
+    resolveCoordinate(fallbackSheet, coordinate) {
+        const sheet = coordinate.sheetName ? this.sheetsByName.get(coordinate.sheetName.trim().toLocaleLowerCase()) : fallbackSheet;
+        if (!sheet) {
+            this.unsupportedMessage = '公式引用了不存在的工作表。';
+            return null;
+        }
+        if (coordinate.row.index < 0 || coordinate.column.index < 0) {
+            this.unsupportedMessage = '公式暂不支持整行或整列引用，请改用有限区域。';
+            return null;
+        }
+        const row = coordinate.row.isAbsolute ? coordinate.row.index : this.options.row + (coordinate.row.index - this.anchor.row);
+        const column = coordinate.column.isAbsolute ? coordinate.column.index : this.options.column + (coordinate.column.index - this.anchor.column);
+        if (row < 0 || column < 0 || row >= MAX_SHEET_ROW || column >= MAX_SHEET_COLUMN) {
+            this.unsupportedMessage = '公式引用超出了工作表边界。';
+            return null;
+        }
+        return {
+            sheet,
+            row,
+            column
+        };
+    }
+    readRange(start, end) {
+        const startCoordinate = this.resolveCoordinate(this.currentSheet, start);
+        const rangeSheet = start.sheetName ? this.sheetsByName.get(start.sheetName.trim().toLocaleLowerCase()) : this.currentSheet;
+        const endCoordinate = rangeSheet ? this.resolveCoordinate(rangeSheet, end) : null;
+        if (!startCoordinate || !endCoordinate || startCoordinate.sheet.id !== endCoordinate.sheet.id) {
+            this.unsupportedMessage ??= '公式区域引用必须位于同一工作表。';
+            return [];
+        }
+        const rowStart = Math.min(startCoordinate.row, endCoordinate.row);
+        const rowEnd = Math.max(startCoordinate.row, endCoordinate.row);
+        const columnStart = Math.min(startCoordinate.column, endCoordinate.column);
+        const columnEnd = Math.max(startCoordinate.column, endCoordinate.column);
+        const area = (rowEnd - rowStart + 1) * (columnEnd - columnStart + 1);
+        if (area <= 0 || area > MAX_SPREADSHEET_LOCAL_FORMULA_REFERENCED_CELLS - this.referencedCells) {
+            this.unsupportedMessage = '公式一次最多读取 1,024 个单元格。';
+            return [];
+        }
+        const values = [];
+        for(let row = rowStart; row <= rowEnd; row += 1){
+            const valuesRow = [];
+            for(let column = columnStart; column <= columnEnd; column += 1)valuesRow.push(this.readCell({
+                sheet: startCoordinate.sheet,
+                row,
+                column
+            }));
+            values.push(valuesRow);
+        }
+        return values;
+    }
+    readCell(coordinate) {
+        this.referencedCells += 1;
+        if (this.referencedCells > MAX_SPREADSHEET_LOCAL_FORMULA_REFERENCED_CELLS) {
+            this.unsupportedMessage = '公式一次最多读取 1,024 个单元格。';
+            return null;
+        }
+        if (this.options.useProposedValue && coordinate.sheet.id === this.currentSheet.id && coordinate.row === this.options.row && coordinate.column === this.options.column) return this.options.proposedValue;
+        const cell = this.cellAt(coordinate.sheet, coordinate.row, coordinate.column);
+        if (!cell) return null;
+        if ('string' == typeof cell.f && cell.f.length > 0 && void 0 === cell.v) {
+            this.unsupportedMessage ??= '公式引用了尚未计算的公式单元格。';
+            return null;
+        }
+        return cell.v ?? null;
+    }
+    cellAt(sheet, row, column) {
+        if (void 0 !== sheet.data) return sheet.data[row]?.[column] ?? null;
+        let cells = this.celldataBySheet.get(sheet.id);
+        if (!cells) {
+            cells = new Map();
+            for (const entry of sheet.celldata ?? []){
+                const value = entry.v && 'object' == typeof entry.v && 'v' in entry.v ? entry.v : {
+                    v: entry.v
+                };
+                cells.set(`${entry.r}_${entry.c}`, value);
+            }
+            this.celldataBySheet.set(sheet.id, cells);
+        }
+        return cells.get(`${row}_${column}`) ?? null;
+    }
+}
+function unsupportedLocalFormula(message) {
+    return {
+        supported: false,
+        value: false,
+        message
+    };
+}
+const MAX_SPREADSHEET_CONDITIONAL_FORMULA_SCAN_CELLS = 10000;
+function spreadsheetConditionalFormatStyles(sheet, formulaSheets) {
+    const styles = new Map();
+    const data = sheet.data ?? [];
+    const rules = conditionalRules(sheet);
+    if (!data.length && !rules.some(isFormulaConditionalRule)) return styles;
+    const blocked = new Set();
+    for (const rule of rules){
+        const matched = new Set();
+        if ('colorGradation' === rule.type) applyColorScale(styles, data, rule, blocked, matched);
+        else if ('dataBar' === rule.type) applyDataBars(styles, data, rule, blocked, matched);
+        else if ('icons' === rule.type) applyIconSet(styles, data, rule, blocked, matched);
+        else applyDefaultRule(styles, data, rule, blocked, matched, formulaSheets, sheet);
+        if (rule.stopIfTrue) for (const key of matched)blocked.add(key);
+    }
+    return styles;
+}
+function isFormulaConditionalRule(rule) {
+    return 'default' === rule.type && 'formula' === rule.conditionName;
+}
+function applyDefaultRule(styles, data, rule, blocked, matched, formulaSheets, currentSheet) {
+    if ('default' !== rule.type || !isConditionalFormatStyle(rule.format) || !rule.conditionName) return;
+    const values = (rule.conditionValue ?? []).map(String);
+    const style = rule.format;
+    if ('formula' === rule.conditionName && values[0]) {
+        for (const range of rule.cellrange)forEachFormulaCell(data, [
+            range
+        ], ({ row, column })=>{
+            if (evaluateFormula(values[0], row, column, range, currentSheet, formulaSheets)) applyDifferentialStyle(styles, blocked, matched, row, column, style);
+        });
+        return;
+    }
+    if ('duplicateValue' === rule.conditionName) {
+        for (const range of rule.cellrange){
+            const positions = cellPositions(data, [
+                range
+            ]).filter(({ row, column })=>null != work_spreadsheet_conditional_format_cellValue(data, row, column));
+            const occurrences = new Map();
+            for (const { row, column } of positions){
+                const key = comparableKey(work_spreadsheet_conditional_format_cellValue(data, row, column));
+                occurrences.set(key, (occurrences.get(key) ?? 0) + 1);
+            }
+            const unique = '1' === values[0];
+            for (const { row, column } of positions){
+                const count = occurrences.get(comparableKey(work_spreadsheet_conditional_format_cellValue(data, row, column))) ?? 0;
+                if (unique && 1 === count || !unique && count > 1) applyDifferentialStyle(styles, blocked, matched, row, column, style);
+            }
+        }
+        return;
+    }
+    if ([
+        'top10',
+        'top10_percent',
+        'last10',
+        'last10_percent'
+    ].includes(rule.conditionName)) {
+        for (const range of rule.cellrange)applyRankRule(styles, data, range, rule.conditionName, values[0], style, blocked, matched);
+        return;
+    }
+    if ('aboveAverage' === rule.conditionName || 'belowAverage' === rule.conditionName) {
+        for (const range of rule.cellrange)applyAverageRule(styles, data, range, rule.conditionName, style, blocked, matched);
+        return;
+    }
+    forEachCell(data, rule.cellrange, ({ row, column })=>{
+        const current = work_spreadsheet_conditional_format_cellValue(data, row, column);
+        if (matchesCondition(current, rule.conditionName, values)) applyDifferentialStyle(styles, blocked, matched, row, column, style);
+    });
+}
+function applyRankRule(styles, data, range, conditionName, sourceRank, style, blocked, matched) {
+    const positions = cellPositions(data, [
+        range
+    ]);
+    const numbers = positions.flatMap(({ row, column })=>{
+        const value = work_spreadsheet_conditional_format_numericCellValue(data, row, column);
+        return null === value ? [] : [
+            value
+        ];
+    });
+    if (!numbers.length) return;
+    numbers.sort((left, right)=>right - left);
+    const requested = Math.max(1, Math.trunc(Number(sourceRank) || 10));
+    const count = conditionName.endsWith('_percent') ? Math.max(1, Math.ceil(Math.min(100, requested) / 100 * numbers.length)) : Math.min(numbers.length, requested);
+    const bottom = conditionName.startsWith('last');
+    const threshold = bottom ? numbers[numbers.length - count] : numbers[count - 1];
+    for (const { row, column } of positions){
+        const value = work_spreadsheet_conditional_format_numericCellValue(data, row, column);
+        if (null !== value && (bottom ? value <= threshold : value >= threshold)) applyDifferentialStyle(styles, blocked, matched, row, column, style);
+    }
+}
+function applyAverageRule(styles, data, range, conditionName, style, blocked, matched) {
+    const positions = cellPositions(data, [
+        range
+    ]);
+    const values = positions.flatMap(({ row, column })=>{
+        const value = work_spreadsheet_conditional_format_numericCellValue(data, row, column);
+        return null === value ? [] : [
+            value
+        ];
+    });
+    if (!values.length) return;
+    const average = values.reduce((sum, value)=>sum + value, 0) / values.length;
+    for (const { row, column } of positions){
+        const value = work_spreadsheet_conditional_format_numericCellValue(data, row, column);
+        if (null !== value && ('aboveAverage' === conditionName ? value > average : value < average)) applyDifferentialStyle(styles, blocked, matched, row, column, style);
+    }
+}
+function applyColorScale(styles, data, rule, blocked, matched) {
+    if (!Array.isArray(rule.format) || rule.format.length < 2) return;
+    const positions = cellPositions(data, rule.cellrange);
+    const numericPositions = positions.flatMap((position)=>{
+        const value = work_spreadsheet_conditional_format_numericCellValue(data, position.row, position.column);
+        return null === value ? [] : [
+            {
+                ...position,
+                value
+            }
+        ];
+    });
+    if (!numericPositions.length) return;
+    const colors = rule.format.slice(0, 3).map(parseSpreadsheetConditionalColor);
+    if (colors.some((color)=>!color)) return;
+    const values = numericPositions.map(({ value })=>value);
+    const options = rule.visualOptions ? normalizeSpreadsheetConditionalVisualOptions(rule.visualOptions, colors.length, 'colorScale') : {
+        thresholds: defaultSpreadsheetColorScaleThresholds(colors.length)
+    };
+    if (!options) return;
+    const points = options.thresholds.map((threshold)=>spreadsheetConditionalThresholdValue(threshold, values));
+    if (points.some((point)=>null === point)) return;
+    const minimum = points[0];
+    const midpoint = 3 === points.length ? points[1] : null;
+    const maximum = points.at(-1);
+    const maximumColor = colors[0];
+    const midpointColor = 3 === colors.length ? colors[1] : null;
+    const minimumColor = colors.at(-1);
+    for (const { row, column, value } of numericPositions){
+        let color;
+        color = maximum === minimum ? midpointColor ?? minimumColor : midpointColor && null !== midpoint && value <= midpoint ? interpolateSpreadsheetConditionalColor(minimumColor, midpointColor, spreadsheetConditionalRatio(value, minimum, midpoint)) : midpointColor && null !== midpoint ? interpolateSpreadsheetConditionalColor(midpointColor, maximumColor, spreadsheetConditionalRatio(value, midpoint, maximum)) : interpolateSpreadsheetConditionalColor(minimumColor, maximumColor, spreadsheetConditionalRatio(value, minimum, maximum));
+        applyConditionalStyle(styles, blocked, matched, row, column, {
+            cellColor: spreadsheetConditionalCssColor(color)
+        });
+    }
+}
+function applyDataBars(styles, data, rule, blocked, matched) {
+    if (!isConditionalFormatStyle(rule.format)) return;
+    const color = rule.format.cellColor;
+    if (!color) return;
+    const positions = cellPositions(data, rule.cellrange);
+    const numericPositions = positions.flatMap((position)=>{
+        const value = work_spreadsheet_conditional_format_numericCellValue(data, position.row, position.column);
+        return null === value ? [] : [
+            {
+                ...position,
+                value
+            }
+        ];
+    });
+    if (!numericPositions.length) return;
+    const values = numericPositions.map(({ value })=>value);
+    const options = rule.visualOptions ? normalizeSpreadsheetConditionalVisualOptions(rule.visualOptions, 2, 'dataBar') : defaultSpreadsheetDataBarOptions();
+    if (!options) return;
+    const points = options.thresholds.map((threshold)=>spreadsheetConditionalThresholdValue(threshold, values));
+    if (points.some((point)=>null === point)) return;
+    const minimum = points[0];
+    const maximum = points[1];
+    for (const { row, column, value } of numericPositions)applyConditionalStyle(styles, blocked, matched, row, column, {
+        dataBar: spreadsheetConditionalDataBar(color, value, minimum, maximum, options.minLength ?? 10, options.maxLength ?? 90, false !== options.showValue)
+    });
+}
+function applyIconSet(styles, data, rule, blocked, matched) {
+    if ('icons' !== rule.type) return;
+    const format = normalizeSpreadsheetConditionalIconSetFormat(rule.format);
+    if (!format) return;
+    const numericPositions = cellPositions(data, rule.cellrange).flatMap((position)=>{
+        const value = work_spreadsheet_conditional_format_numericCellValue(data, position.row, position.column);
+        return null === value ? [] : [
+            {
+                ...position,
+                value
+            }
+        ];
+    });
+    const values = numericPositions.map(({ value })=>value);
+    for (const { row, column, value } of numericPositions){
+        const icon = spreadsheetConditionalIconForValue(format, value, values);
+        if (icon) applyConditionalStyle(styles, blocked, matched, row, column, {
+            icon
+        });
+    }
+}
+function matchesCondition(value, name, conditions) {
+    if (null == value) return false;
+    if ('textContains' === name) return String(value).toLowerCase().includes((conditions[0] ?? '').toLowerCase());
+    if ('equal' === name) return 0 === compareValues(value, conditions[0]);
+    if ('notEqual' === name) return 0 !== compareValues(value, conditions[0]);
+    if ('greaterThan' === name) return compareValues(value, conditions[0]) > 0;
+    if ('greaterThanOrEqual' === name) return compareValues(value, conditions[0]) >= 0;
+    if ('lessThan' === name) return compareValues(value, conditions[0]) < 0;
+    if ('lessThanOrEqual' === name) return compareValues(value, conditions[0]) <= 0;
+    if ('between' === name || 'notBetween' === name) {
+        const lower = Math.min(Number(conditions[0]), Number(conditions[1]));
+        const upper = Math.max(Number(conditions[0]), Number(conditions[1]));
+        if (!Number.isFinite(lower) || !Number.isFinite(upper)) return false;
+        const between = Number(value) >= lower && Number(value) <= upper;
+        return 'between' === name ? between : !between;
+    }
+    return false;
+}
+function evaluateFormula(source, row, column, baseRange, currentSheet, formulaSheets) {
+    const sheets = [
+        toFormulaSheet(currentSheet),
+        ...(formulaSheets ?? []).filter((sheet)=>sheet.id && sheet.id !== currentSheet.id).map(toFormulaSheet)
+    ];
+    const result = evaluateSpreadsheetLocalFormula(source, {
+        sheets,
+        sheetId: currentSheet.id ?? '',
+        row,
+        column,
+        anchorRow: baseRange.row[0],
+        anchorColumn: baseRange.column[0]
+    });
+    return result.supported && spreadsheetLocalFormulaBoolean(result.value);
+}
+function applyDifferentialStyle(styles, blocked, matched, row, column, style) {
+    const patch = {};
+    if (style.textColor) patch.textColor = style.textColor;
+    if (style.cellColor) patch.cellColor = style.cellColor;
+    applyConditionalStyle(styles, blocked, matched, row, column, patch);
+}
+function applyConditionalStyle(styles, blocked, matched, row, column, patch) {
+    const key = cellKey(row, column);
+    if (blocked.has(key)) return;
+    matched.add(key);
+    if (Object.keys(patch).length) patchCellStyle(styles, row, column, patch);
+}
+function patchCellStyle(styles, row, column, patch) {
+    const key = cellKey(row, column);
+    styles.set(key, {
+        ...patch,
+        ...styles.get(key)
+    });
+}
+function conditionalRules(sheet) {
+    if (!Array.isArray(sheet.luckysheet_conditionformat_save)) return [];
+    return sheet.luckysheet_conditionformat_save.filter(isConditionalRule);
+}
+function isConditionalRule(value) {
+    if (!value || 'object' != typeof value) return false;
+    const rule = value;
+    return [
+        'default',
+        'colorGradation',
+        'dataBar',
+        'icons'
+    ].includes(String(rule.type)) && Array.isArray(rule.cellrange);
+}
+function isConditionalFormatStyle(value) {
+    return Boolean(value) && !Array.isArray(value) && 'object' == typeof value && !('iconSet' in value) && 'textColor' in value && 'cellColor' in value;
+}
+function cellPositions(data, ranges) {
+    const positions = [];
+    const seen = new Set();
+    forEachCell(data, ranges, (position)=>{
+        const key = cellKey(position.row, position.column);
+        if (!seen.has(key)) {
+            seen.add(key);
+            positions.push(position);
+        }
+    });
+    return positions;
+}
+function cellKey(row, column) {
+    return `${row}_${column}`;
+}
+function forEachCell(data, ranges, visit) {
+    for (const [row, cells] of spreadsheet_sparse_sparseArrayEntries(data))for (const [column] of spreadsheet_sparse_sparseArrayEntries(cells))if (ranges.some((range)=>row >= range.row[0] && row <= range.row[1] && column >= range.column[0] && column <= range.column[1])) visit({
+        row,
+        column
+    });
+}
+function forEachFormulaCell(data, ranges, visit) {
+    for (const range of ranges){
+        const area = (range.row[1] - range.row[0] + 1) * (range.column[1] - range.column[0] + 1);
+        if (area > 0 && area <= MAX_SPREADSHEET_CONDITIONAL_FORMULA_SCAN_CELLS) {
+            for(let row = range.row[0]; row <= range.row[1]; row += 1)for(let column = range.column[0]; column <= range.column[1]; column += 1)visit({
+                row,
+                column
+            });
+            continue;
+        }
+        forEachCell(data, [
+            range
+        ], visit);
+    }
+}
+function work_spreadsheet_conditional_format_cellValue(data, row, column) {
+    return data[row]?.[column]?.v ?? null;
+}
+function work_spreadsheet_conditional_format_numericCellValue(data, row, column) {
+    const value = work_spreadsheet_conditional_format_cellValue(data, row, column);
+    return 'number' == typeof value && Number.isFinite(value) ? value : null;
+}
+function comparableKey(value) {
+    return `${typeof value}:${String(value)}`;
+}
+function compareValues(left, right) {
+    const leftNumber = Number(left);
+    const rightNumber = Number(right);
+    if (String(left).trim() && String(right).trim() && Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) return leftNumber === rightNumber ? 0 : leftNumber > rightNumber ? 1 : -1;
+    return String(left).localeCompare(String(right));
+}
+function toFormulaSheet(sheet) {
+    return {
+        id: sheet.id ?? '',
+        name: sheet.name,
+        data: sheet.data,
+        celldata: sheet.celldata
+    };
+}
+const xlsxNativeFillCellKeys = [
+    XLSX_PATTERN_FILL_CELL_KEY,
+    XLSX_GRADIENT_FILL_CELL_KEY
+];
+function activeXlsxNativeFill(cell) {
+    const gradient = activeXlsxGradientFill(cell);
+    const pattern = activeXlsxPatternFill(cell);
+    if (Boolean(gradient) === Boolean(pattern)) return;
+    return gradient ? {
+        kind: 'gradient',
+        value: gradient
+    } : {
+        kind: 'pattern',
+        value: pattern
+    };
+}
+function deleteXlsxNativeFills(cell) {
+    deleteXlsxGradientFill(cell);
+    deleteXlsxPatternFill(cell);
+}
+function xlsxNativeFillSemanticColors(fill) {
+    if (!fill) return [];
+    return 'gradient' === fill.kind ? xlsxGradientFillSemanticColors(fill.value) : xlsxPatternFillSemanticColors(fill.value);
+}
+function xlsxNativeFillKey(fill) {
+    if (!fill) return '';
+    return 'gradient' === fill.kind ? `gradient:${xlsxGradientFillKey(fill.value)}` : `pattern:${xlsxPatternFillKey(fill.value)}`;
+}
+function spreadsheetCellFillFormat(cell) {
+    const nativeFill = activeXlsxNativeFill(cell);
+    if (nativeFill) return nativeFill;
+    const color = normalizeSpreadsheetFillColor(cell?.bg);
+    return color ? {
+        color,
+        kind: 'solid'
+    } : {
+        kind: 'none'
+    };
+}
+function normalizeSpreadsheetCellFillFormat(value) {
+    if (!spreadsheet_cell_fill_format_isRecord(value)) return null;
+    if ('none' === value.kind) return {
+        kind: 'none'
+    };
+    if ('solid' === value.kind) {
+        const color = normalizeSpreadsheetFillColor(value.color);
+        return color ? {
+            color,
+            kind: 'solid'
+        } : null;
+    }
+    if ('pattern' === value.kind) {
+        const fill = normalizeXlsxPatternFill(value.value);
+        return fill ? {
+            kind: 'pattern',
+            value: fill
+        } : null;
+    }
+    if ('gradient' === value.kind) {
+        const fill = normalizeXlsxGradientFill(value.value);
+        return fill ? {
+            kind: 'gradient',
+            value: fill
+        } : null;
+    }
+    return null;
+}
+function withSpreadsheetCellFillFormat(cell, fill) {
+    const normalized = normalizeSpreadsheetCellFillFormat(fill);
+    if (!normalized) return null;
+    const next = {
+        ...cell
+    };
+    deleteXlsxNativeFills(next);
+    if ('none' === normalized.kind) {
+        delete next.bg;
+        return next;
+    }
+    if ('solid' === normalized.kind) {
+        next.bg = normalized.color;
+        return next;
+    }
+    if ('pattern' === normalized.kind) {
+        next.bg = normalized.value.backgroundColor;
+        return withXlsxPatternFill(next, normalized.value);
+    }
+    next.bg = xlsxGradientFillFallbackColor(normalized.value);
+    return withXlsxGradientFill(next, normalized.value);
+}
+function normalizeSpreadsheetFillColor(value) {
+    if ('string' != typeof value) return null;
+    const color = value.trim().toLowerCase();
+    if (/^#[0-9a-f]{6}$/.test(color)) return color;
+    if (!/^#[0-9a-f]{3}$/.test(color)) return null;
+    return `#${[
+        ...color.slice(1)
+    ].map((character)=>character.repeat(2)).join('')}`;
+}
+function spreadsheet_cell_fill_format_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function createSpreadsheetSortAppearanceRows(sheet, range, rows) {
+    const data = liveSpreadsheetSortMatrix(sheet, range, rows);
+    const conditional = spreadsheetConditionalFormatStyles({
+        ...sheet,
+        data
+    });
+    return rows.map((row, rowOffset)=>row.map((cell, columnOffset)=>{
+            const direct = spreadsheetSortDirectCellAppearance(cell);
+            const style = conditional.get(`${range.row[0] + rowOffset}_${range.column[0] + columnOffset}`);
+            const conditionalCellColor = normalizeSpreadsheetSortColor(style?.cellColor);
+            const conditionalFontColor = normalizeSpreadsheetSortColor(style?.textColor);
+            return {
+                cellColor: void 0 !== conditionalCellColor ? conditionalCellColor : direct.cellColor,
+                fontColor: void 0 !== conditionalFontColor ? conditionalFontColor : direct.fontColor,
+                icon: normalizeSpreadsheetSortIcon(style?.icon) ?? null
+            };
+        }));
+}
+function createSpreadsheetSortDirectAppearanceRows(rows) {
+    return rows.map((row)=>row.map(spreadsheetSortDirectCellAppearance));
+}
+function spreadsheetSortAppearanceFields(rows, range, orientation, hasHeader) {
+    const vertical = 'top-to-bottom' === orientation;
+    const fieldCount = vertical ? range.column[1] - range.column[0] + 1 : range.row[1] - range.row[0] + 1;
+    return Array.from({
+        length: fieldCount
+    }, (_, offset)=>{
+        const cellColors = [];
+        const fontColors = [];
+        const icons = [];
+        const seenCellColors = new Set();
+        const seenFontColors = new Set();
+        const seenIcons = new Set();
+        const appearances = vertical ? rows.slice(hasHeader ? 1 : 0).map((row)=>row[offset]) : rows[offset] ?? [];
+        for (const appearance of appearances)if (appearance) {
+            if (void 0 !== appearance.cellColor) appendUniqueColor(cellColors, seenCellColors, appearance.cellColor);
+            appendUniqueColor(fontColors, seenFontColors, appearance.fontColor);
+            if (appearance.icon) {
+                const key = spreadsheetSortIconTargetKey(appearance.icon);
+                if (!seenIcons.has(key)) {
+                    seenIcons.add(key);
+                    icons.push({
+                        ...appearance.icon
+                    });
+                }
+            }
+        }
+        return {
+            index: (vertical ? range.column[0] : range.row[0]) + offset,
+            cellColors,
+            fontColors,
+            icons
+        };
+    });
+}
+function normalizeSpreadsheetSortColor(value) {
+    if (null === value) return null;
+    if ('string' != typeof value) return;
+    const source = value.trim();
+    const shorthand = /^#([0-9a-f]{3})$/iu.exec(source);
+    const parsed = parseSpreadsheetConditionalColor(shorthand ? `#${[
+        ...shorthand[1]
+    ].map((character)=>character.repeat(2)).join('')}` : source);
+    return parsed ? spreadsheetSortHexColor(parsed) : void 0;
+}
+function normalizeSpreadsheetSortIcon(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    if (!isSpreadsheetConditionalIconSetName(source.iconSet) || !Number.isSafeInteger(source.index) || source.index < 0 || source.index >= spreadsheetConditionalIconSetCount(source.iconSet)) return null;
+    return {
+        iconSet: source.iconSet,
+        index: source.index
+    };
+}
+function spreadsheetSortAppearanceTargetValue(target) {
+    if ('icon' === target.kind) return `icon:${target.icon.iconSet}:${target.icon.index}`;
+    const value = target.color ?? ('cell-color' === target.kind ? 'none' : 'automatic');
+    return `${target.kind}:${value}`;
+}
+function parseSpreadsheetSortAppearanceTargetValue(value) {
+    if (value.startsWith('cell-color:')) {
+        const source = value.slice(11);
+        if ('none' === source) return {
+            kind: 'cell-color',
+            color: null
+        };
+        const color = normalizeSpreadsheetSortColor(source);
+        return 'string' == typeof color ? {
+            kind: 'cell-color',
+            color
+        } : null;
+    }
+    if (value.startsWith('font-color:')) {
+        const source = value.slice(11);
+        if ('automatic' === source) return {
+            kind: 'font-color',
+            color: null
+        };
+        const color = normalizeSpreadsheetSortColor(source);
+        return 'string' == typeof color ? {
+            kind: 'font-color',
+            color
+        } : null;
+    }
+    const icon = /^icon:([^:]+):(\d+)$/u.exec(value);
+    if (!icon) return null;
+    const normalized = normalizeSpreadsheetSortIcon({
+        iconSet: icon[1],
+        index: Number(icon[2])
+    });
+    return normalized ? {
+        kind: 'icon',
+        icon: normalized
+    } : null;
+}
+function spreadsheetSortAppearanceTargetLabel(target) {
+    if ('cell-color' === target.kind) return target.color ? `单元格颜色 ${target.color.toUpperCase()}` : '无单元格颜色';
+    if ('font-color' === target.kind) return target.color ? `字体颜色 ${target.color.toUpperCase()}` : '自动字体颜色';
+    const count = spreadsheetConditionalIconSetCount(target.icon.iconSet);
+    const appearance = spreadsheetConditionalIconAppearance({
+        ...target.icon,
+        count,
+        showValue: true
+    });
+    return `${appearance.glyph} ${appearance.label}`;
+}
+function spreadsheetSortAppearanceTargets(field, kind) {
+    if (!field) return [];
+    if ('cell-color' === kind) return field.cellColors.map((color)=>({
+            kind,
+            color
+        }));
+    if ('font-color' === kind) return field.fontColors.map((color)=>({
+            kind,
+            color
+        }));
+    return field.icons.map((icon)=>({
+            kind,
+            icon: {
+                ...icon
+            }
+        }));
+}
+function spreadsheetSortAppearanceTargetsEqual(left, right) {
+    return spreadsheetSortAppearanceTargetValue(left) === spreadsheetSortAppearanceTargetValue(right);
+}
+function spreadsheetSortCellMatchesAppearance(appearance, target) {
+    if (!appearance) return false;
+    if ('cell-color' === target.kind) return appearance.cellColor === target.color;
+    if ('font-color' === target.kind) return appearance.fontColor === target.color;
+    return Boolean(appearance.icon && spreadsheetSortIconTargetKey(appearance.icon) === spreadsheetSortIconTargetKey(target.icon));
+}
+function spreadsheetSortDirectCellAppearance(cell) {
+    const fill = spreadsheetCellFillFormat(cell);
+    const fontColor = normalizeSpreadsheetSortColor(cell?.fc);
+    return {
+        cellColor: 'solid' === fill.kind ? fill.color : 'none' === fill.kind ? null : void 0,
+        fontColor: 'string' == typeof fontColor ? fontColor : null,
+        icon: null
+    };
+}
+function liveSpreadsheetSortMatrix(sheet, range, rows) {
+    const data = cloneSparseMatrix(sheet.data);
+    for (const entry of sheet.celldata ?? []){
+        const row = data[entry.r] ? [
+            ...data[entry.r]
+        ] : [];
+        if (void 0 === row[entry.c]) row[entry.c] = entry.v;
+        data[entry.r] = row;
+    }
+    for(let rowOffset = 0; rowOffset < rows.length; rowOffset += 1){
+        const absoluteRow = range.row[0] + rowOffset;
+        const target = data[absoluteRow] ? [
+            ...data[absoluteRow]
+        ] : [];
+        const source = rows[rowOffset] ?? [];
+        for(let columnOffset = 0; columnOffset < source.length; columnOffset += 1)target[range.column[0] + columnOffset] = source[columnOffset] ?? null;
+        data[absoluteRow] = target;
+    }
+    return data;
+}
+function appendUniqueColor(target, seen, color) {
+    const key = color ?? 'none';
+    if (seen.has(key)) return;
+    seen.add(key);
+    target.push(color);
+}
+function spreadsheetSortIconTargetKey(target) {
+    return `${target.iconSet}:${target.index}`;
+}
+function spreadsheetSortHexColor(color) {
+    return `#${[
+        color.red,
+        color.green,
+        color.blue
+    ].map((channel)=>channel.toString(16).padStart(2, '0')).join('')}`;
+}
+const DEFAULT_SPREADSHEET_SORT_TEXT_OPTIONS = Object.freeze({
+    caseSensitive: false,
+    textMethod: 'pinyin'
+});
+const SPREADSHEET_SORT_COLLATION_PROBES = Object.freeze({
+    pinyin: Object.freeze([
+        '阿',
+        '丁',
+        '王',
+        '赵'
+    ]),
+    stroke: Object.freeze([
+        '丁',
+        '王',
+        '安',
+        '阿',
+        '赵'
+    ])
+});
+function isSpreadsheetSortTextMethod(value) {
+    return 'pinyin' === value || 'stroke' === value;
+}
+function createSpreadsheetSortTextComparator(options) {
+    try {
+        const collator = new Intl.Collator(`zh-CN-u-co-${options.textMethod}`, {
+            caseFirst: 'lower',
+            numeric: false,
+            sensitivity: options.caseSensitive ? 'case' : 'base',
+            usage: 'sort'
+        });
+        if (!spreadsheetSortCollatorSupportsMethod(collator, options.textMethod)) return null;
+        return collator.compare;
+    } catch  {
+        return null;
+    }
+}
+function spreadsheetSortCollatorSupportsMethod(collator, textMethod) {
+    const probe = SPREADSHEET_SORT_COLLATION_PROBES[textMethod];
+    for(let index = 1; index < probe.length; index += 1){
+        const previous = probe[index - 1];
+        const current = probe[index];
+        if (void 0 === previous || void 0 === current) return false;
+        if (collator.compare(previous, current) >= 0) return false;
+    }
+    return true;
+}
+const MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRIES = 256;
+const MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRY_CODE_POINTS = 128;
+const MAX_SPREADSHEET_SORT_CUSTOM_LIST_CODE_POINTS = 4096;
+const MAX_SPREADSHEET_SORT_USER_CUSTOM_LISTS = 32;
+function parseSpreadsheetSortCustomList(text) {
+    return validateSpreadsheetSortCustomList(text.split(/\r?\n|,|，/u).map((entry)=>entry.trim()).filter(Boolean));
+}
+function validateSpreadsheetSortCustomList(input) {
+    if (!Array.isArray(input)) return customListError('invalid-entry');
+    if (input.length < 2) return customListError('not-enough-entries');
+    if (input.length > MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRIES) return customListError('too-many-entries');
+    const entries = [];
+    const seen = new Set();
+    let totalCodePoints = 0;
+    for (const candidate of input){
+        if ('string' != typeof candidate) return customListError('invalid-entry');
+        const entry = candidate.trim();
+        if (!entry) return customListError('invalid-entry');
+        const codePoints = Array.from(entry).length;
+        if (codePoints > MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRY_CODE_POINTS) return customListError('entry-too-long');
+        totalCodePoints += codePoints;
+        if (totalCodePoints > MAX_SPREADSHEET_SORT_CUSTOM_LIST_CODE_POINTS) return customListError('list-too-long');
+        const matchKey = spreadsheetSortCustomListMatchKey(entry);
+        if (seen.has(matchKey)) return customListError('duplicate-entry');
+        seen.add(matchKey);
+        entries.push(entry);
+    }
+    return {
+        ok: true,
+        entries
+    };
+}
+function createSpreadsheetSortCustomList(entries, source = 'session') {
+    const validation = validateSpreadsheetSortCustomList(entries);
+    if (!validation.ok) return null;
+    const normalized = Object.freeze([
+        ...validation.entries
+    ]);
+    return Object.freeze({
+        source,
+        entries: normalized,
+        label: spreadsheetSortCustomListLabel(normalized)
+    });
+}
+function mergeSpreadsheetSortCustomLists(lists) {
+    const merged = [
+        ...SPREADSHEET_SORT_BUILT_IN_CUSTOM_LISTS
+    ];
+    let userListCount = 0;
+    for (const candidate of lists){
+        if ('stored' !== candidate.source && 'session' !== candidate.source) continue;
+        const list = createSpreadsheetSortCustomList(candidate.entries, candidate.source);
+        if (!(!list || merged.some((item)=>spreadsheetSortCustomListsEqual(item.entries, list.entries)))) {
+            if (userListCount >= MAX_SPREADSHEET_SORT_USER_CUSTOM_LISTS) break;
+            merged.push(list);
+            userListCount += 1;
+        }
+    }
+    return Object.freeze(merged);
+}
+function spreadsheetSortCustomListsEqual(left, right) {
+    return left.length === right.length && left.every((entry, index)=>spreadsheetSortCustomListMatchKey(entry) === spreadsheetSortCustomListMatchKey(right[index] ?? ''));
+}
+function spreadsheetSortCustomListMatchKey(value) {
+    return String(value).normalize('NFKC').trim().toLocaleLowerCase('zh-CN');
+}
+function spreadsheetSortCustomListLabel(entries) {
+    const visible = entries.slice(0, 3).map((entry)=>truncateSpreadsheetSortCustomListLabelEntry(entry));
+    return `${visible.join(' → ')}${entries.length > 3 ? ' → …' : ''}`;
+}
+function truncateSpreadsheetSortCustomListLabelEntry(entry) {
+    const characters = Array.from(entry);
+    return characters.length > 18 ? `${characters.slice(0, 17).join('')}…` : entry;
+}
+function customListError(code) {
+    const messages = {
+        'duplicate-entry': '自定义序列不能包含重复项（忽略大小写和全半角差异）。',
+        'entry-too-long': `每个序列项最多包含 ${MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRY_CODE_POINTS} 个字符。`,
+        'invalid-entry': '自定义序列只能包含非空文本项。',
+        'list-too-long': `一个自定义序列最多包含 ${MAX_SPREADSHEET_SORT_CUSTOM_LIST_CODE_POINTS.toLocaleString('en-US')} 个字符。`,
+        'not-enough-entries': '自定义序列至少需要两个项目。',
+        'too-many-entries': `一个自定义序列最多包含 ${MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRIES} 个项目。`
+    };
+    return {
+        ok: false,
+        code,
+        message: messages[code]
+    };
+}
+function builtInCustomList(label, entries) {
+    return Object.freeze({
+        source: 'built-in',
+        entries: Object.freeze([
+            ...entries
+        ]),
+        label
+    });
+}
+const SPREADSHEET_SORT_BUILT_IN_CUSTOM_LISTS = Object.freeze([
+    builtInCustomList('月份（一月 → 十二月）', [
+        '一月',
+        '二月',
+        '三月',
+        '四月',
+        '五月',
+        '六月',
+        '七月',
+        '八月',
+        '九月',
+        '十月',
+        '十一月',
+        '十二月'
+    ]),
+    builtInCustomList('星期（星期日 → 星期六）', [
+        '星期日',
+        '星期一',
+        '星期二',
+        '星期三',
+        '星期四',
+        '星期五',
+        '星期六'
+    ]),
+    builtInCustomList('周（周日 → 周六）', [
+        '周日',
+        '周一',
+        '周二',
+        '周三',
+        '周四',
+        '周五',
+        '周六'
+    ]),
+    builtInCustomList('月份（January → December）', [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December'
+    ]),
+    builtInCustomList('月份（Jan → Dec）', [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec'
+    ]),
+    builtInCustomList('星期（Sunday → Saturday）', [
+        'Sunday',
+        'Monday',
+        'Tuesday',
+        'Wednesday',
+        'Thursday',
+        'Friday',
+        'Saturday'
+    ]),
+    builtInCustomList('星期（Sun → Sat）', [
+        'Sun',
+        'Mon',
+        'Tue',
+        'Wed',
+        'Thu',
+        'Fri',
+        'Sat'
+    ])
+]);
+const MAX_SPREADSHEET_SORT_KEYS = 64;
+const MAX_SPREADSHEET_SORT_CELLS = 1000000;
+const MAX_SPREADSHEET_SORT_HEADER_LENGTH = 48;
+function createSpreadsheetSortRangePlan(sheet, selectedRange) {
+    const selected = normalizeSpreadsheetCellRange(selectedRange);
+    if (!selected) return null;
+    const owned = spreadsheetSortOwnedRangeContaining(sheet, selected);
+    if (owned) return {
+        selectedRange: selected,
+        expandedRange: spreadsheetCellRangesEqual(owned.range, selected) ? null : owned.range
+    };
+    const currentRegion = spreadsheetCurrentRegion(sheet, selected);
+    return {
+        selectedRange: selected,
+        expandedRange: currentRegion && !spreadsheetCellRangesEqual(currentRegion, selected) ? currentRegion : null
+    };
+}
+function createSpreadsheetSortRangeDialogSource(sheetName, request) {
+    if (!request.expanded) return null;
+    return {
+        sheetName,
+        selectedRangeReference: formatSpreadsheetCellRanges([
+            request.selected.range
+        ]),
+        expandedRangeReference: formatSpreadsheetCellRanges([
+            request.expanded.range
+        ]),
+        canSortSelection: request.selected.available,
+        canSortExpandedRange: request.expanded.available,
+        ...request.expanded.scope ? {
+            ownedScope: request.expanded.scope
+        } : {}
+    };
+}
+function createSpreadsheetSortDialogSource(sheetId, sheetName, target, rows, customLists = [], appearanceRows) {
+    const range = normalizeSpreadsheetCellRange(target.range);
+    if (!range || spreadsheetSortRangeError(range)) return null;
+    const width = range.column[1] - range.column[0] + 1;
+    const height = range.row[1] - range.row[0] + 1;
+    if (!spreadsheetSortRowsMatchRange(rows, range)) return null;
+    const hasHeader = height > 2 && spreadsheetSortRowsHaveHeader(rows);
+    const resolvedHasHeader = target.scope?.hasHeader ?? hasHeader;
+    const activeColumn = spreadsheetSortActiveIndex(target.activeColumn, range.column);
+    const activeRow = spreadsheetSortActiveIndex(target.activeRow, range.row);
+    const header = rows[0] ?? [];
+    const resolvedAppearanceRows = appearanceRows && spreadsheetSortAppearanceRowsMatch(rows, appearanceRows) ? appearanceRows : createSpreadsheetSortDirectAppearanceRows(rows);
+    return {
+        sheetId,
+        sheetName,
+        range,
+        rangeReference: formatSpreadsheetCellRanges([
+            range
+        ]),
+        activeRow,
+        appearanceRows: resolvedAppearanceRows,
+        customLists: mergeSpreadsheetSortCustomLists(customLists),
+        ...target.scope ? {
+            scope: target.scope
+        } : {},
+        columns: Array.from({
+            length: width
+        }, (_, offset)=>{
+            const index = range.column[0] + offset;
+            const name = spreadsheetSortHeaderText(header[offset]);
+            const coordinate = spreadsheetSortColumnLabel(index);
+            return {
+                index,
+                label: name ? `${coordinate}（${name}）` : coordinate
+            };
+        }),
+        rows: Array.from({
+            length: height
+        }, (_, offset)=>{
+            const index = range.row[0] + offset;
+            return {
+                index,
+                label: `行 ${index + 1}`
+            };
+        }),
+        value: {
+            orientation: 'top-to-bottom',
+            ...DEFAULT_SPREADSHEET_SORT_TEXT_OPTIONS,
+            hasHeader: resolvedHasHeader,
+            keys: [
+                {
+                    index: activeColumn,
+                    direction: 'ascending'
+                }
+            ]
+        }
+    };
+}
+function spreadsheetSortRowsMatchRange(rows, range) {
+    const normalized = normalizeSpreadsheetCellRange(range);
+    if (!normalized) return false;
+    const width = normalized.column[1] - normalized.column[0] + 1;
+    const height = normalized.row[1] - normalized.row[0] + 1;
+    return rows.length === height && rows.every((row)=>row.length === width);
+}
+function spreadsheetSortRowsFromSheet(sheet, range) {
+    const normalized = normalizeSpreadsheetCellRange(range);
+    if (!normalized || spreadsheetSortRangeError(normalized)) return null;
+    const width = normalized.column[1] - normalized.column[0] + 1;
+    const height = normalized.row[1] - normalized.row[0] + 1;
+    const rows = Array.from({
+        length: height
+    }, ()=>Array(width).fill(null));
+    for(let row = normalized.row[0]; row <= normalized.row[1]; row += 1){
+        const source = sheet.data?.[row];
+        if (!source) continue;
+        const target = rows[row - normalized.row[0]];
+        for(let column = normalized.column[0]; column <= normalized.column[1]; column += 1)target[column - normalized.column[0]] = source[column] ?? null;
+    }
+    for (const entry of sheet.celldata ?? []){
+        if (entry.r < normalized.row[0] || entry.r > normalized.row[1] || entry.c < normalized.column[0] || entry.c > normalized.column[1]) continue;
+        const row = rows[entry.r - normalized.row[0]];
+        const column = entry.c - normalized.column[0];
+        if (null === row[column]) row[column] = entry.v ?? null;
+    }
+    return rows;
+}
+function spreadsheetSortOwnedRangeForExactRange(sheet, range) {
+    const normalized = normalizeSpreadsheetCellRange(range);
+    if (!normalized) return null;
+    const matches = spreadsheetSortOwnedRanges(sheet).filter((candidate)=>spreadsheetCellRangesEqual(candidate.range, normalized));
+    return 1 === matches.length ? matches[0] : null;
+}
+function spreadsheetSortOwnedRangeContaining(sheet, range) {
+    const matches = spreadsheetSortOwnedRanges(sheet).filter((candidate)=>spreadsheetSortRangeContains(candidate.range, range));
+    return 1 === matches.length ? matches[0] : null;
+}
+function spreadsheetSortOwnedRanges(sheet) {
+    const ranges = [];
+    const autoFilter = normalizeSpreadsheetCellRange(sheet.filter_select ?? {
+        row: [],
+        column: []
+    });
+    if (autoFilter && autoFilter.row[1] > autoFilter.row[0]) ranges.push({
+        range: autoFilter,
+        scope: {
+            kind: 'auto-filter',
+            hasHeader: true
+        }
+    });
+    for (const table of sheet.tables ?? []){
+        const tableRange = normalizeSpreadsheetCellRange(table.range);
+        if (!tableRange || !table.id || 0 === table.columns.length) continue;
+        const width = tableRange.column[1] - tableRange.column[0] + 1;
+        if (width !== table.columns.length) continue;
+        const endRow = tableRange.row[1] - Number(table.totalsRow);
+        if (!(endRow <= tableRange.row[0])) ranges.push({
+            range: {
+                row: [
+                    tableRange.row[0],
+                    endRow
+                ],
+                column: [
+                    ...tableRange.column
+                ]
+            },
+            scope: {
+                kind: 'table',
+                tableId: table.id,
+                hasHeader: table.headerRow
+            }
+        });
+    }
+    return ranges;
+}
+function spreadsheetSortRangeContains(outer, inner) {
+    return outer.row[0] <= inner.row[0] && outer.row[1] >= inner.row[1] && outer.column[0] <= inner.column[0] && outer.column[1] >= inner.column[1];
+}
+function validateSpreadsheetSortRequest(request) {
+    const range = normalizeSpreadsheetCellRange(request.range);
+    if (!range || 'string' != typeof request.sheetId || !request.sheetId.trim()) return spreadsheetSortError('invalid-range');
+    const scope = normalizeSpreadsheetSortOwnedScope(request.scope);
+    if (void 0 !== request.scope && !scope) return spreadsheetSortError('invalid-scope');
+    if ('top-to-bottom' !== request.orientation && 'left-to-right' !== request.orientation) return spreadsheetSortError('invalid-orientation');
+    const caseSensitive = void 0 === request.caseSensitive ? DEFAULT_SPREADSHEET_SORT_TEXT_OPTIONS.caseSensitive : request.caseSensitive;
+    if ('boolean' != typeof caseSensitive) return spreadsheetSortError('invalid-case-sensitivity');
+    const textMethod = void 0 === request.textMethod ? DEFAULT_SPREADSHEET_SORT_TEXT_OPTIONS.textMethod : request.textMethod;
+    if (!isSpreadsheetSortTextMethod(textMethod)) return spreadsheetSortError('invalid-text-method');
+    if ('left-to-right' === request.orientation && request.hasHeader) return spreadsheetSortError('invalid-header');
+    const rangeError = spreadsheetSortRangeError(range);
+    if (rangeError) return rangeError;
+    if (!Array.isArray(request.keys) || !request.keys.length) return spreadsheetSortError('missing-key');
+    if (request.keys.length > MAX_SPREADSHEET_SORT_KEYS) return spreadsheetSortError('too-many-keys');
+    const keyRange = 'top-to-bottom' === request.orientation ? range.column : range.row;
+    const outOfRangeCode = 'top-to-bottom' === request.orientation ? 'column-out-of-range' : 'row-out-of-range';
+    const keys = [];
+    for (const key of request.keys){
+        if (!Number.isSafeInteger(key.index) || key.index < keyRange[0] || key.index > keyRange[1]) return spreadsheetSortError(outOfRangeCode);
+        if (void 0 !== key.sortOn) {
+            if ('first' !== key.position && 'last' !== key.position || void 0 !== key.customList || void 0 !== key.direction) return spreadsheetSortError('invalid-appearance');
+            if ('cell-color' === key.sortOn || 'font-color' === key.sortOn) {
+                const color = normalizeSpreadsheetSortColor(key.color);
+                if (void 0 === color || void 0 !== key.icon) return spreadsheetSortError('invalid-appearance');
+                const normalized = {
+                    index: key.index,
+                    sortOn: key.sortOn,
+                    color,
+                    position: key.position
+                };
+                if (!appendSpreadsheetSortKey(keys, normalized)) return spreadsheetSortError('duplicate-key');
+                continue;
+            }
+            if ('icon' === key.sortOn && void 0 === key.color) {
+                const icon = normalizeSpreadsheetSortIcon(key.icon);
+                if (icon) {
+                    const normalized = {
+                        index: key.index,
+                        sortOn: 'icon',
+                        icon,
+                        position: key.position
+                    };
+                    if (!appendSpreadsheetSortKey(keys, normalized)) return spreadsheetSortError('duplicate-key');
+                    continue;
+                }
+            }
+            return spreadsheetSortError('invalid-appearance');
+        }
+        if (void 0 !== key.customList) {
+            if (void 0 !== key.direction) return spreadsheetSortError('invalid-custom-list');
+            const customList = validateSpreadsheetSortCustomList(key.customList);
+            if (!customList.ok) return spreadsheetSortError('invalid-custom-list');
+            if (!appendSpreadsheetSortKey(keys, {
+                index: key.index,
+                customList: customList.entries
+            })) return spreadsheetSortError('duplicate-key');
+            continue;
+        }
+        if ('ascending' !== key.direction && 'descending' !== key.direction) return spreadsheetSortError('invalid-direction');
+        if (!appendSpreadsheetSortKey(keys, {
+            index: key.index,
+            direction: key.direction
+        })) return spreadsheetSortError('duplicate-key');
+    }
+    if ('top-to-bottom' === request.orientation) {
+        const rowCount = range.row[1] - range.row[0] + 1;
+        if (rowCount - (request.hasHeader ? 1 : 0) < 2) return spreadsheetSortError('not-enough-rows');
+    } else if (range.column[1] - range.column[0] + 1 < 2) return spreadsheetSortError('not-enough-columns');
+    return {
+        ok: true,
+        request: {
+            sheetId: request.sheetId,
+            range,
+            orientation: request.orientation,
+            caseSensitive,
+            textMethod,
+            hasHeader: Boolean(request.hasHeader),
+            keys,
+            ...scope ? {
+                scope
+            } : {}
+        }
+    };
+}
+function spreadsheetSortAppearanceRowsMatch(rows, appearances) {
+    return rows.length === appearances.length && rows.every((row, index)=>row.length === (appearances[index]?.length ?? -1));
+}
+function spreadsheetSortError(code) {
+    const messages = {
+        'column-out-of-range': '排序列必须位于当前选定区域内。',
+        'duplicate-key': '同一行或列不能重复使用相同的值或外观排序条件。',
+        'formula-reference-out-of-range': '排序会使相对公式引用超出工作表范围，因此未应用任何更改。',
+        'invalid-appearance': '外观排序条件或当前颜色/图标快照无效，因此未应用任何更改。',
+        'invalid-case-sensitivity': '请选择有效的大小写比较规则。',
+        'invalid-custom-list': '自定义排序序列无效，请检查项目数量、长度和重复项。',
+        'invalid-direction': '请选择有效的升序或降序次序。',
+        'invalid-header': '按行排序会移动所有选定列，不能保留标题列。',
+        'invalid-matrix': '排序只能应用到已完整读取的矩形区域。',
+        'invalid-orientation': '请选择有效的按列或按行排序方向。',
+        'invalid-range': '请选择一个有效的连续单元格区域。',
+        'invalid-scope': '排序区域的表格或筛选所有权已变化，请重新打开排序。',
+        'invalid-text-method': '请选择拼音排序或笔画排序。',
+        'missing-key': '请至少添加一个排序条件。',
+        'not-enough-columns': '当前区域没有足够的数据列可供按行排序。',
+        'not-enough-rows': '当前区域没有足够的数据行可供排序。',
+        'range-too-large': `一次最多可排序 ${MAX_SPREADSHEET_SORT_CELLS.toLocaleString('en-US')} 个单元格。`,
+        'row-out-of-range': '排序行必须位于当前选定区域内。',
+        'too-many-keys': `一次最多可设置 ${MAX_SPREADSHEET_SORT_KEYS} 个排序条件。`,
+        'unsupported-text-method': '当前运行环境不支持所选中文排序方法，因此未应用任何更改。',
+        'unsupported-linked-cell': '当前区域包含坐标关联的超链接，尚不能安全地随排序移动。'
+    };
+    return {
+        ok: false,
+        code,
+        message: messages[code]
+    };
+}
+function normalizeSpreadsheetSortOwnedScope(value) {
+    if (void 0 === value) return null;
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    if ('auto-filter' === value.kind && true === value.hasHeader && Object.keys(value).every((key)=>'kind' === key || 'hasHeader' === key)) return {
+        kind: 'auto-filter',
+        hasHeader: true
+    };
+    if ('table' === value.kind && 'string' == typeof value.tableId && Boolean(value.tableId.trim()) && 'boolean' == typeof value.hasHeader && Object.keys(value).every((key)=>'kind' === key || 'tableId' === key || 'hasHeader' === key)) return {
+        kind: 'table',
+        tableId: value.tableId,
+        hasHeader: value.hasHeader
+    };
+    return null;
+}
+function spreadsheetSortRangeError(range) {
+    const area = spreadsheetCellRangeArea(range);
+    if (!Number.isSafeInteger(area) || area > MAX_SPREADSHEET_SORT_CELLS) return spreadsheetSortError('range-too-large');
+    return null;
+}
+function spreadsheetSortRowsHaveHeader(rows) {
+    const first = rows[0];
+    if (!first?.length) return false;
+    const labels = first.map(spreadsheetSortHeaderText);
+    return labels.every(Boolean) && new Set(labels.map((label)=>label.toLocaleLowerCase())).size === labels.length;
+}
+function appendSpreadsheetSortKey(keys, key) {
+    const identity = spreadsheetSortKeyIdentity(key);
+    if (keys.some((candidate)=>spreadsheetSortKeyIdentity(candidate) === identity)) return false;
+    keys.push(key);
+    return true;
+}
+function spreadsheetSortKeyIdentity(key) {
+    if ('cell-color' === key.sortOn || 'font-color' === key.sortOn) return `${key.index}:${spreadsheetSortAppearanceTargetValue({
+        kind: key.sortOn,
+        color: key.color
+    })}`;
+    if ('icon' === key.sortOn) return `${key.index}:${spreadsheetSortAppearanceTargetValue({
+        kind: 'icon',
+        icon: key.icon
+    })}`;
+    return `${key.index}:values`;
+}
+function spreadsheetSortActiveIndex(active, range) {
+    return active >= range[0] && active <= range[1] ? active : range[0];
+}
+function spreadsheetSortHeaderText(cell) {
+    if (cell?.f || 'string' != typeof cell?.v) return '';
+    const value = cell.v;
+    return Array.from(value.trim()).slice(0, MAX_SPREADSHEET_SORT_HEADER_LENGTH).join('');
+}
+function spreadsheetSortColumnLabel(column) {
+    return formatSpreadsheetCellRanges([
+        {
+            row: [
+                0,
+                0
+            ],
+            column: [
+                column,
+                column
+            ]
+        }
+    ]).replace(/\d+$/, '');
+}
+function reconcileSpreadsheetFiltersAfterFortune(sheets, sourceSheets, operations = [], context = {
+    now: new Date()
+}) {
+    const coordinates = spreadsheetCellOperationCoordinates(operations);
+    return sheets.map((sheet, index)=>{
+        const source = sourceSheet(sheet, sourceSheets, index);
+        if (!source || !spreadsheetSheetHasCriteria(source) || !spreadsheetFilterReconciliationIsBounded(source) || !spreadsheetFilterRangesWereEdited(source, operations, coordinates)) return sheet;
+        const previousTableOwnedRows = spreadsheetTableFilterOwnedRows(source, context);
+        const manuallyHiddenRows = workSpreadsheetAutoFilterManuallyHiddenRows(source);
+        for (const row of previousTableOwnedRows)manuallyHiddenRows.delete(row);
+        let next = sheet;
+        if (normalizedWorkSpreadsheetAutoFilterRange(sheet.filter_select) && workSpreadsheetAutoFilterCriteriaEntries(source).length) next = workSpreadsheetSheetWithReappliedAutoFilterCriteria(sheet, source, manuallyHiddenRows, context);
+        const hiddenRows = new Set(manuallyHiddenRows);
+        for (const row of workSpreadsheetAutoFilterOwnedRows(next))hiddenRows.add(row);
+        for (const row of spreadsheetTableFilterOwnedRows(next, context))hiddenRows.add(row);
+        const rowhidden = Object.fromEntries([
+            ...hiddenRows
+        ].sort(compareSpreadsheetRowKeys).map((row)=>[
+                row,
+                0
+            ]));
+        return {
+            ...next,
+            config: {
+                ...next.config ?? {},
+                rowhidden
+            }
+        };
+    });
+}
+function reconcileSpreadsheetFiltersAfterSort(sheet, source, range, sourceIndexes, context = {
+    now: new Date()
+}) {
+    if (!spreadsheetFilterReconciliationIsBounded(source) || !spreadsheetSortSourceIndexesAreValid(range, sourceIndexes)) return null;
+    const reconciled = reconcileSpreadsheetFiltersAfterFortune([
+        sheet
+    ], [
+        source
+    ], [], context)[0];
+    if (!reconciled) return null;
+    let filter = reconciled.filter;
+    const autoFilter = normalizedWorkSpreadsheetAutoFilterRange(source.filter_select);
+    if (autoFilter && autoFilter.row[0] === range.row[0] && autoFilter.row[1] === range.row[1] && autoFilter.column[0] === range.column[0] && autoFilter.column[1] === range.column[1]) filter = spreadsheetFilterWithRemappedOpaqueEntries(reconciled, source, range, sourceIndexes);
+    const manuallyHiddenRows = workSpreadsheetAutoFilterManuallyHiddenRows(source);
+    for (const row of spreadsheetTableFilterOwnedRows(source, context))manuallyHiddenRows.delete(row);
+    const withFilter = {
+        ...reconciled,
+        filter
+    };
+    const hiddenRows = new Set(manuallyHiddenRows);
+    for (const row of workSpreadsheetAutoFilterOwnedRows(withFilter))hiddenRows.add(row);
+    for (const row of spreadsheetTableFilterOwnedRows(withFilter, context))hiddenRows.add(row);
+    const rowhidden = Object.fromEntries([
+        ...hiddenRows
+    ].sort(compareSpreadsheetRowKeys).map((row)=>[
+            row,
+            0
+        ]));
+    return {
+        ...sheet,
+        filter,
+        config: {
+            ...sheet.config ?? {},
+            rowhidden
+        }
+    };
+}
+function spreadsheetFilterReconciliationIsBounded(sheet) {
+    let cellVisits = 0;
+    const autoFilter = normalizedWorkSpreadsheetAutoFilterRange(sheet.filter_select);
+    if (autoFilter) {
+        const filterCount = Object.keys(sheet.filter ?? {}).length;
+        cellVisits += (autoFilter.row[1] - autoFilter.row[0]) * Math.max(filterCount, workSpreadsheetAutoFilterCriteriaEntries(sheet).length);
+    }
+    for (const table of sheet.tables ?? []){
+        const range = spreadsheetTableFilterRange(table);
+        if (range) {
+            cellVisits += (range.row[1] - range.row[0]) * table.filters.length;
+            if (!Number.isSafeInteger(cellVisits) || cellVisits > MAX_SPREADSHEET_SORT_CELLS) return false;
+        }
+    }
+    return Number.isSafeInteger(cellVisits) && cellVisits <= MAX_SPREADSHEET_SORT_CELLS;
+}
+function spreadsheetFilterWithRemappedOpaqueEntries(reconciled, source, range, sourceIndexes) {
+    const next = {
+        ...reconciled.filter ?? {}
+    };
+    const typedColumns = new Set(workSpreadsheetAutoFilterCriteriaEntries(source).map((entry)=>String(entry.column)));
+    for (const [column, entry] of Object.entries(source.filter ?? {}))if (!typedColumns.has(column) && spreadsheet_filter_reconciliation_isRecord(entry)) next[column] = {
+        ...entry,
+        rowhidden: spreadsheetRemappedFilterRows(entry.rowhidden, range, sourceIndexes)
+    };
+    return next;
+}
+function spreadsheetRemappedFilterRows(value, range, sourceIndexes) {
+    const sourceRows = spreadsheet_filter_reconciliation_isRecord(value) ? value : {};
+    const rowhidden = {};
+    const dataStart = range.row[0] + 1;
+    sourceIndexes.forEach((sourceIndex, targetIndex)=>{
+        if (Object.hasOwn(sourceRows, String(dataStart + sourceIndex))) rowhidden[String(dataStart + targetIndex)] = 0;
+    });
+    return rowhidden;
+}
+function spreadsheetSortSourceIndexesAreValid(range, sourceIndexes) {
+    const count = range.row[1] - range.row[0];
+    return sourceIndexes.length === count && sourceIndexes.every((index)=>Number.isSafeInteger(index) && index >= 0 && index < count) && new Set(sourceIndexes).size === count;
+}
+function spreadsheetSheetHasCriteria(sheet) {
+    return Boolean(workSpreadsheetAutoFilterCriteriaEntries(sheet).length || sheet.tables?.some((table)=>table.filters.length));
+}
+function spreadsheetFilterRangesWereEdited(sheet, operations, coordinates) {
+    if (!operations.length) return true;
+    if (!sheet.id) return false;
+    const sheetCoordinates = coordinates?.get(sheet.id);
+    if (sheetCoordinates) {
+        const ranges = spreadsheetFilterRanges(sheet);
+        return [
+            ...sheetCoordinates.values()
+        ].some(({ column, row })=>ranges.some((range)=>row >= range.row[0] && row <= range.row[1] && column >= range.column[0] && column <= range.column[1]));
+    }
+    return operations.some((operation)=>operation.id === sheet.id);
+}
+function spreadsheetFilterRanges(sheet) {
+    const ranges = [];
+    const autoFilter = normalizedWorkSpreadsheetAutoFilterRange(sheet.filter_select);
+    if (autoFilter && workSpreadsheetAutoFilterCriteriaEntries(sheet).length) ranges.push(autoFilter);
+    for (const table of sheet.tables ?? []){
+        if (!table.filters.length) continue;
+        const range = spreadsheetTableFilterRange(table);
+        if (range) ranges.push(range);
+    }
+    return ranges;
+}
+function spreadsheetTableFilterOwnedRows(sheet, context) {
+    const hidden = new Set();
+    for (const table of sheet.tables ?? []){
+        const range = spreadsheetTableFilterRange(table);
+        if (range) for (const filter of table.filters){
+            const column = range.column[0] + filter.column;
+            const rowhidden = workSpreadsheetFilterHiddenRows(sheet, range, column, filter.criteria, context);
+            for (const row of Object.keys(rowhidden ?? {}))hidden.add(row);
+        }
+    }
+    return hidden;
+}
+function spreadsheetTableFilterRange(table) {
+    if (!table.headerRow || !table.filters.length) return null;
+    const rowStart = spreadsheet_filter_reconciliation_finiteIndex(table.range.row[0]);
+    const rowEnd = spreadsheet_filter_reconciliation_finiteIndex(table.range.row[1]);
+    const columnStart = spreadsheet_filter_reconciliation_finiteIndex(table.range.column[0]);
+    const columnEnd = spreadsheet_filter_reconciliation_finiteIndex(table.range.column[1]);
+    if (null === rowStart || null === rowEnd || null === columnStart || null === columnEnd) return null;
+    const end = Math.max(rowStart, rowEnd) - Number(table.totalsRow);
+    const start = Math.min(rowStart, rowEnd);
+    if (end <= start) return null;
+    return {
+        row: [
+            start,
+            end
+        ],
+        column: [
+            Math.min(columnStart, columnEnd),
+            Math.max(columnStart, columnEnd)
+        ]
+    };
+}
+function sourceSheet(sheet, sources, index) {
+    return sources.find((candidate)=>candidate.id === sheet.id) ?? sources[index];
+}
+function spreadsheet_filter_reconciliation_finiteIndex(value) {
+    return 'number' == typeof value && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function compareSpreadsheetRowKeys(left, right) {
+    return Number(left) - Number(right);
+}
+function spreadsheet_filter_reconciliation_isRecord(value) {
+    return Boolean(value && 'object' == typeof value && !Array.isArray(value));
+}
+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();
+        const calculatedColumnRows = new Map();
+        const editedTotalsColumns = new Map();
+        if (!operations.length) for (const table of tables)reconcileColumns.add(table.id);
+        for (const operation of sheetOperations){
+            const structure = spreadsheetTableStructureChangeFromOperation(operation);
+            if (structure) {
+                transformCalculatedColumnRows(calculatedColumnRows, structure);
+                const transformed = [];
+                for (const table of tables){
+                    if ('row' === structure.axis && 'insert' === structure.kind) {
+                        const insertedRows = rowsInsertedIntoSpreadsheetTableBody(table, structure);
+                        if (insertedRows.length) {
+                            const rows = calculatedColumnRows.get(table.id) ?? new Set();
+                            for (const row of insertedRows)rows.add(row);
+                            calculatedColumnRows.set(table.id, rows);
+                        }
+                    }
+                    const next = transformSpreadsheetTableStructure(table, structure);
+                    if (next) {
+                        transformed.push(next);
+                        if (next !== table) reconcileColumns.add(table.id);
+                    }
+                }
+                tables = transformed;
+                continue;
+            }
+            const coordinate = spreadsheetCellCoordinateFromOperation(operation);
+            if (!coordinate) continue;
+            const table = tables.find((candidate)=>spreadsheetTableContainsCell(candidate, coordinate.row, coordinate.column));
+            if (table) {
+                reconcileColumns.add(table.id);
+                if (table.totalsRow && coordinate.row === table.range.row[1]) {
+                    const offset = coordinate.column - table.range.column[0];
+                    if (offset >= 0 && offset < table.columns.length) {
+                        const offsets = editedTotalsColumns.get(table.id) ?? new Set();
+                        offsets.add(offset);
+                        editedTotalsColumns.set(table.id, offsets);
+                    }
+                }
+            }
+        }
+        const updates = [];
+        const readCell = spreadsheet_table_reconciliation_spreadsheetSheetCellReader(sheet);
+        tables = tables.map((table)=>{
+            if (!reconcileColumns.has(table.id)) return table;
+            const columns = canonicalSpreadsheetTableColumns(table, readCell);
+            const calculatedColumns = reconcileSpreadsheetTableCalculatedColumns(sheet, {
+                ...table,
+                columns
+            });
+            const reconciledColumns = reconcileSpreadsheetTableTotalsColumns(sheet, {
+                ...table,
+                columns: calculatedColumns
+            }, editedTotalsColumns.get(table.id));
+            if (table.headerRow) for (const [offset, column] of reconciledColumns.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, reconciledColumns) ? table : {
+                ...table,
+                columns: reconciledColumns
+            };
+        });
+        let withCalculatedColumns = sheet;
+        for (const table of tables){
+            const rows = calculatedColumnRows.get(table.id);
+            if (rows?.size) withCalculatedColumns = fillSpreadsheetTableCalculatedColumns(withCalculatedColumns, table, [
+                ...rows
+            ]);
+        }
+        const withHeaders = stampSpreadsheetTableHeaderCells(withCalculatedColumns, updates);
+        let withTotals = withHeaders;
+        for (const table of tables){
+            const previous = source.tables.find((candidate)=>candidate.id === table.id);
+            withTotals = synchronizeSpreadsheetTableTotalsRow(withTotals, previous, table);
+        }
+        return {
+            ...withTotals,
+            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 spreadsheetTableContainsCell(table, row, column) {
+    return row >= table.range.row[0] && row <= table.range.row[1] && column >= table.range.column[0] && column <= table.range.column[1];
+}
+function rowsInsertedIntoSpreadsheetTableBody(table, change) {
+    if ('row' !== change.axis) return [];
+    const transformed = transformSpreadsheetTableAxisForInsertion(table.range.row, change);
+    if (!transformed.inside) return [];
+    const insertion = change.index + ('rightbottom' === change.direction ? 1 : 0);
+    const bodyStart = table.range.row[0] + Number(table.headerRow);
+    if (insertion < bodyStart) return [];
+    return Array.from({
+        length: change.count
+    }, (_, offset)=>insertion + offset);
+}
+function transformCalculatedColumnRows(rowsByTable, change) {
+    if ('row' !== change.axis || !rowsByTable.size) return;
+    if ('insert' === change.kind) {
+        const insertion = change.index + ('rightbottom' === change.direction ? 1 : 0);
+        for (const [tableId, rows] of rowsByTable){
+            const next = new Set();
+            for (const row of rows)next.add(row >= insertion ? row + change.count : row);
+            rowsByTable.set(tableId, next);
+        }
+        return;
+    }
+    const count = change.end - change.start + 1;
+    for (const [tableId, rows] of rowsByTable){
+        const next = new Set();
+        for (const row of rows)if (row < change.start) next.add(row);
+        else if (row > change.end) next.add(row - count);
+        rowsByTable.set(tableId, next);
+    }
+}
+function transformSpreadsheetTableAxisForInsertion(axis, change) {
+    const start = axis[0] ?? 0;
+    const end = axis[1] ?? start;
+    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 {
+            ...table.columns[offset] ?? {},
+            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 spreadsheet_table_reconciliation_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 spreadsheet_sparse_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 && column.calculatedFormula === right[index]?.calculatedFormula && column.totalsFunction === right[index]?.totalsFunction && column.totalsLabel === right[index]?.totalsLabel && column.totalsFormula === right[index]?.totalsFormula);
+}
+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);
+    const columnStart = Math.min(selection.column[0] ?? 0, selection.column[1] ?? selection.column[0] ?? 0);
+    const columnEnd = Math.max(selection.column[0] ?? 0, selection.column[1] ?? selection.column[0] ?? 0);
+    const start = `${spreadsheetColumnLabel(columnStart)}${rowStart + 1}`;
+    const end = `${spreadsheetColumnLabel(columnEnd)}${rowEnd + 1}`;
+    return start === end ? start : `${start}:${end}`;
+}
+function spreadsheetSingleRange(selection) {
+    return {
+        row: finiteSpreadsheetSelectionAxis(selection.row),
+        column: finiteSpreadsheetSelectionAxis(selection.column)
+    };
+}
+function spreadsheet_editor_support_spreadsheetCellAt(sheet, row, column) {
+    if (!sheet) return null;
+    const safeRow = finiteSpreadsheetIndex(row, 0);
+    const safeColumn = finiteSpreadsheetIndex(column, 0);
+    return sheet.data?.[safeRow]?.[safeColumn] ?? sheet.celldata?.find((entry)=>entry.r === safeRow && entry.c === safeColumn)?.v ?? null;
+}
+function spreadsheetSelectionSummary(sheet, selection) {
+    const summary = {
+        average: null,
+        nonEmptyCount: 0,
+        numericCount: 0,
+        sum: null
+    };
+    if (!sheet) return summary;
+    const range = spreadsheetSingleRange(selection);
+    let sum = 0;
+    const collect = (cell)=>{
+        if (!cell || !spreadsheet_editor_support_spreadsheetCellHasContent(cell)) return;
+        summary.nonEmptyCount += 1;
+        if ('number' != typeof cell.v || !Number.isFinite(cell.v)) return;
+        summary.numericCount += 1;
+        sum += cell.v;
+    };
+    if (sheet.data?.length) {
+        const rowStart = range.row[0] ?? 0;
+        const rowEnd = Math.min(range.row[1] ?? rowStart, sheet.data.length - 1);
+        const columnStart = range.column[0] ?? 0;
+        const columnEnd = range.column[1] ?? columnStart;
+        for (const rowIndex of sparseArrayIndexes(sheet.data)){
+            if (rowIndex < rowStart || rowIndex > rowEnd) continue;
+            const row = sheet.data[rowIndex];
+            if (row) {
+                for (const columnIndex of sparseArrayIndexes(row))if (!(columnIndex < columnStart) && !(columnIndex > columnEnd)) collect(row[columnIndex]);
+            }
+        }
+    } else {
+        const rowStart = range.row[0] ?? 0;
+        const rowEnd = range.row[1] ?? rowStart;
+        const columnStart = range.column[0] ?? 0;
+        const columnEnd = range.column[1] ?? columnStart;
+        for (const entry of sheet.celldata ?? [])if (!(entry.r < rowStart) && !(entry.r > rowEnd) && !(entry.c < columnStart) && !(entry.c > columnEnd)) collect(entry.v);
+    }
+    if (summary.numericCount > 0) {
+        summary.sum = sum;
+        summary.average = sum / summary.numericCount;
+    }
+    return summary;
+}
+function spreadsheetFontSizeOptions(current) {
+    const values = [
+        ...spreadsheetFontSizes
+    ];
+    if (current && !values.includes(current)) values.push(current);
+    return values.sort((left, right)=>left - right).map((value)=>({
+            value: String(value),
+            label: String(value)
+        }));
+}
+function spreadsheetFontFamilyOptions(current) {
+    const options = officeFontFamilies.map(({ cssFamily, group, label, name })=>({
+            value: name,
+            group,
+            label,
+            previewStyle: {
+                fontFamily: cssFamily
+            },
+            searchText: `${name} ${label}`
+        }));
+    const normalizedCurrent = current?.trim();
+    if (normalizedCurrent && !options.some(({ value })=>value === normalizedCurrent)) options.push({
+        value: normalizedCurrent,
+        group: '文档字体',
+        label: normalizedCurrent,
+        previewStyle: {
+            fontFamily: normalizedCurrent
+        },
+        searchText: normalizedCurrent
+    });
+    return options;
+}
+function spreadsheetSheetsWithFiniteSelections(sheets) {
+    return sheets.map((sheet)=>({
+            ...sheet,
+            luckysheet_select_save: (sheet.luckysheet_select_save?.length ? sheet.luckysheet_select_save : [
+                void 0
+            ]).map(finiteSpreadsheetSelection)
+        }));
+}
+function spreadsheetSheetsForFortune(sheets, namedRanges = []) {
+    const startedAt = spreadsheetProjectionNow();
+    let populatedCellCount = 0;
+    const projectedSheets = sheets.map((sheet)=>{
+        const { celldata: sourceCellData, data, ...sourceMetadata } = sheet;
+        const projected = structuredClone(sourceMetadata);
+        const profile = spreadsheetMatrixProfile(data);
+        if (data && profile?.fortuneReady) {
+            populatedCellCount += profile.populatedCellCount;
+            return {
+                ...projected,
+                data
+            };
+        }
+        const fortuneProjection = spreadsheetMatrixForFortune({
+            ...projected,
+            ...void 0 === data ? {} : {
+                data
+            },
+            ...void 0 === sourceCellData ? {} : {
+                celldata: sourceCellData
+            }
+        }, projected.config?.merge);
+        populatedCellCount += fortuneProjection.populatedCellCount;
+        return {
+            ...projected,
+            data: fortuneProjection.data
+        };
+    });
+    recordSpreadsheetProjectionMeasure(startedAt, spreadsheetProjectionNow(), {
+        populatedCellCount,
+        sheetCount: sheets.length
+    });
+    return materializeSpreadsheetDependentListsForFortune(projectedSheets, namedRanges);
+}
+function spreadsheetMatrixForFortune(sheet, merges) {
+    const declaredRows = spreadsheet_editor_support_positiveSpreadsheetDimension(sheet.row);
+    const declaredColumns = spreadsheet_editor_support_positiveSpreadsheetDimension(sheet.column);
+    const hasDeclaredGrid = declaredRows > 0 && declaredColumns > 0;
+    let rowCount = hasDeclaredGrid ? declaredRows : 60;
+    let columnCount = hasDeclaredGrid ? declaredColumns : 26;
+    let populatedCellCount = 0;
+    const shownCommentCells = [];
+    const projected = [];
+    const setSourceCell = (rowIndex, columnIndex, cell)=>{
+        rowCount = Math.max(rowCount, rowIndex + 1);
+        columnCount = Math.max(columnCount, columnIndex + 1);
+        const row = projected[rowIndex] ?? [];
+        projected[rowIndex] = row;
+        row[columnIndex] = cloneSpreadsheetCellForFortune(cell);
+        if (cell.ps?.isShow) shownCommentCells.push({
+            c: columnIndex,
+            r: rowIndex
+        });
+        populatedCellCount += 1;
+    };
+    if (void 0 !== sheet.data) {
+        rowCount = Math.max(rowCount, sheet.data.length);
+        for (const rowIndex of sparseArrayIndexes(sheet.data)){
+            const sourceRow = sheet.data[rowIndex];
+            if (sourceRow) {
+                columnCount = Math.max(columnCount, sourceRow.length);
+                for (const columnIndex of sparseArrayIndexes(sourceRow)){
+                    const cell = sourceRow[columnIndex];
+                    if (null != cell) setSourceCell(rowIndex, columnIndex, cell);
+                }
+            }
+        }
+    } else for (const entry of sheet.celldata ?? [])if (null != entry.v) setSourceCell(entry.r, entry.c, entry.v);
+    for (const merge of Object.values(merges ?? {})){
+        rowCount = Math.max(rowCount, merge.r + merge.rs);
+        columnCount = Math.max(columnCount, merge.c + merge.cs);
+        for(let rowIndex = merge.r; rowIndex < merge.r + merge.rs; rowIndex += 1){
+            const row = projected[rowIndex] ?? [];
+            projected[rowIndex] = row;
+            for(let columnIndex = merge.c; columnIndex < merge.c + merge.cs; columnIndex += 1)row[columnIndex] = Object.freeze({
+                ...row[columnIndex] ?? {},
+                mc: rowIndex === merge.r && columnIndex === merge.c ? {
+                    ...merge
+                } : {
+                    r: merge.r,
+                    c: merge.c
+                }
+            });
+        }
+    }
+    projected.length = rowCount;
+    projected[0] ??= [];
+    for (const rowIndex of sparseArrayIndexes(projected)){
+        const row = projected[rowIndex];
+        if (row) {
+            row.length = Math.max(row.length, columnCount);
+            Object.freeze(row);
+        }
+    }
+    attachSpreadsheetShownCommentCells(projected, Object.freeze(shownCommentCells.map((cell)=>Object.freeze(cell))));
+    Object.freeze(projected);
+    return {
+        data: projected,
+        populatedCellCount
+    };
+}
+function cloneSpreadsheetCellForFortune(cell) {
+    const clone = {
+        ...cell
+    };
+    if (cell.mc) clone.mc = {
+        ...cell.mc
+    };
+    if (cell.ct) clone.ct = {
+        ...cell.ct,
+        ...void 0 === cell.ct.s ? {} : {
+            s: structuredClone(cell.ct.s)
+        }
+    };
+    if (cell.ps) clone.ps = {
+        ...cell.ps
+    };
+    if (cell.hl) clone.hl = {
+        ...cell.hl
+    };
+    if (cell.spl && 'object' == typeof cell.spl) clone.spl = structuredClone(cell.spl);
+    Object.freeze(clone);
+    return clone;
+}
+function spreadsheetProjectionNow() {
+    return globalThis.performance?.now?.() ?? Date.now();
+}
+function recordSpreadsheetProjectionMeasure(start, end, detail) {
+    try {
+        globalThis.performance?.measure('a3s-office.spreadsheet.fortune-projection', {
+            detail,
+            end,
+            start
+        });
+    } catch  {}
+}
+function spreadsheetSheetsFromFortune(sheets, sourceSheets, operations = [], dateSystem = '1900') {
+    const startedAt = spreadsheetProjectionNow();
+    const filterContext = {
+        dateSystem,
+        now: new Date()
+    };
+    const incremental = projectSpreadsheetSheetsFromFortuneOperations(sheets, sourceSheets, operations);
+    if (incremental) {
+        recordSpreadsheetControlledProjectionMeasure(startedAt, spreadsheetProjectionNow(), {
+            affectedCellCount: incremental.affectedCellCount,
+            incremental: true,
+            operationCount: operations.length
+        });
+        return restoreSpreadsheetDependentListProjections(reconcileSpreadsheetFiltersAfterFortune(reconcileSpreadsheetTablesAfterFortune(incremental.sheets, sourceSheets, operations), sourceSheets, operations, filterContext));
+    }
+    const operationCoordinatesBySheet = spreadsheetCellOperationCoordinates(operations);
+    const projected = sheets.map((sheet, index)=>{
+        const source = (sheet.id ? sourceSheets.find((candidate)=>candidate.id === sheet.id) : void 0) ?? sourceSheets[index];
+        const operationCoordinates = sheet.id ? operationCoordinatesBySheet?.get(sheet.id) : void 0;
+        const cells = spreadsheetPopulatedCellData(sheet).map((entry)=>{
+            if (!source || !entry.v) return entry;
+            const previous = spreadsheet_editor_support_spreadsheetCellAt(source, entry.r, entry.c);
+            const exactCellOperation = operationCoordinates?.has(spreadsheetCellOperationKey(entry.r, entry.c));
+            const textStableNonStructuralCallback = null !== operationCoordinatesBySheet && sameSpreadsheetRichTextCellText(previous, entry.v);
+            if (!exactCellOperation && !textStableNonStructuralCallback) return entry;
+            const reconciled = exactCellOperation ? reconcileSpreadsheetRichTextCellEdit(previous, entry.v, takeSpreadsheetRichTextPaste(source, entry.r, entry.c, entry.v)) : restoreSpreadsheetRichTextCellRuns(previous, entry.v);
+            return reconciled === entry.v ? entry : {
+                ...entry,
+                v: reconciled
+            };
+        });
+        const { celldata: _cellData, data: _data, ...metadata } = sheet;
+        const useMatrix = source ? void 0 !== source.data : void 0 !== sheet.data;
+        if (!useMatrix) return {
+            ...metadata,
+            celldata: cells
+        };
+        const data = [];
+        data.length = Math.max(sheet.data?.length ?? 0, source?.data?.length ?? 0, spreadsheet_editor_support_positiveSpreadsheetDimension(sheet.row));
+        for (const { r: rowIndex, c: columnIndex, v: cell } of cells){
+            const row = data[rowIndex] ?? [];
+            data[rowIndex] = row;
+            row.length = Math.max(row.length, sheet.data?.[rowIndex]?.length ?? 0, source?.data?.[rowIndex]?.length ?? 0, spreadsheet_editor_support_positiveSpreadsheetDimension(sheet.column));
+            row[columnIndex] = cell;
+        }
+        return {
+            ...metadata,
+            data
+        };
+    });
+    recordSpreadsheetControlledProjectionMeasure(startedAt, spreadsheetProjectionNow(), {
+        affectedCellCount: 0,
+        incremental: false,
+        operationCount: operations.length
+    });
+    return restoreSpreadsheetDependentListProjections(reconcileSpreadsheetFiltersAfterFortune(reconcileSpreadsheetTablesAfterFortune(projected, sourceSheets, operations), sourceSheets, operations, filterContext));
+}
+function recordSpreadsheetControlledProjectionMeasure(start, end, detail) {
+    try {
+        globalThis.performance?.measure('a3s-office.spreadsheet.controlled-projection', {
+            detail,
+            end,
+            start
+        });
+    } catch  {}
+}
+function finiteSpreadsheetSelection(selection) {
+    const row = finiteSpreadsheetSelectionAxis(selection?.row);
+    const column = finiteSpreadsheetSelectionAxis(selection?.column);
+    return {
+        ...selection,
+        row,
+        column,
+        row_focus: finiteSpreadsheetFocus(selection?.row_focus, row),
+        column_focus: finiteSpreadsheetFocus(selection?.column_focus, column)
+    };
+}
+function sameSpreadsheetWorkbookState(changed, rendered) {
+    return changed.length === rendered.length && changed.every((sheet, index)=>sameSpreadsheetSheetState(sheet, rendered[index]));
+}
+function sameSpreadsheetWorkbookStateAfterOperations(changed, rendered, operations) {
+    if (0 === operations.length || operations.length > 10000) return null;
+    if (changed.length !== rendered.length || !changed.every((sheet, index)=>sameSpreadsheetHistoryValue(spreadsheetSheetMetadata(sheet), spreadsheetSheetMetadata(rendered[index])))) return false;
+    const changedById = spreadsheet_editor_support_spreadsheetSheetsById(changed);
+    const renderedById = spreadsheet_editor_support_spreadsheetSheetsById(rendered);
+    if (!changedById || !renderedById) return null;
+    const coordinates = new Map();
+    for (const operation of operations){
+        if ('insertRowCol' === operation.op || 'deleteRowCol' === operation.op || 'addSheet' === operation.op || 'deleteSheet' === operation.op || 0 === operation.path.length) return false;
+        if (!operation.id || !changedById.has(operation.id) || !renderedById.has(operation.id)) return null;
+        if ('data' !== operation.path[0]) continue;
+        const row = operation.path[1];
+        const column = operation.path[2];
+        if (operation.path.length < 3 || !spreadsheet_editor_support_isSpreadsheetCoordinate(row) || !spreadsheet_editor_support_isSpreadsheetCoordinate(column)) return null;
+        coordinates.set(`${operation.id}:${row}:${column}`, {
+            column,
+            row,
+            sheetId: operation.id
+        });
+    }
+    for (const { column, row, sheetId } of coordinates.values())if (!sameSpreadsheetHistoryValue(spreadsheet_editor_support_spreadsheetCellAt(changedById.get(sheetId), row, column), spreadsheet_editor_support_spreadsheetCellAt(renderedById.get(sheetId), row, column))) return false;
+    return true;
+}
+function sameSpreadsheetHistoryContent(left, right) {
+    if (left === right) return true;
+    const { sheets: leftSheets, ...leftMetadata } = left;
+    const { sheets: rightSheets, ...rightMetadata } = right;
+    return sameSpreadsheetHistoryValue(leftMetadata, rightMetadata) && leftSheets.length === rightSheets.length && leftSheets.every((sheet, index)=>sameSpreadsheetSheetState(sheet, rightSheets[index]));
+}
+function spreadsheetContentWithSelection(content, sheetId, selection) {
+    return spreadsheetContentWithSelections(content, sheetId, selection ? [
+        selection
+    ] : []);
+}
+function spreadsheetContentWithSelections(content, sheetId, selections) {
+    if (!sheetId || !selections.length) return content;
+    const nextSelections = selections.map(finiteSpreadsheetSelection);
+    let changed = false;
+    const sheets = content.sheets.map((sheet)=>{
+        if (sheet.id !== sheetId) return sheet;
+        changed = true;
+        return {
+            ...sheet,
+            luckysheet_select_save: nextSelections
+        };
+    });
+    return changed ? {
+        ...content,
+        sheets
+    } : content;
+}
+function isSpreadsheetNativeTextUndoTarget(target) {
+    if (!(target instanceof HTMLElement)) return false;
+    if (isSpreadsheetCellEditingTarget(target)) return true;
+    if (target.closest('.fortune-container')) return false;
+    return target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement || target.isContentEditable || Boolean(target.closest('[contenteditable="true"]'));
+}
+function isSpreadsheetCellEditingTarget(target) {
+    if (!isSpreadsheetCellEditorTarget(target)) return false;
+    if (!(target instanceof Element)) return false;
+    const formulaInput = target.closest('.fortune-fx-input');
+    if (formulaInput) return true;
+    const cellInput = target.closest('.luckysheet-cell-input');
+    if (!cellInput) return false;
+    const inputBox = cellInput.closest('.luckysheet-input-box');
+    if (!inputBox) return true;
+    const zIndex = Number.parseInt(inputBox.style.zIndex || getComputedStyle(inputBox).zIndex, 10);
+    return !Number.isFinite(zIndex) || zIndex >= 0;
+}
+function isSpreadsheetCellEditorTarget(target) {
+    return target instanceof Element && Boolean(target.closest('.fortune-fx-input, .luckysheet-cell-input'));
+}
+function spreadsheetFormulaBarSelectAllTarget(event) {
+    if (event.defaultPrevented || event.repeat || event.altKey || event.shiftKey || !(event.metaKey || event.ctrlKey) || 'a' !== event.key.toLocaleLowerCase() || !(event.target instanceof Element)) return null;
+    const formulaBar = event.target.closest('.fortune-fx-input');
+    return formulaBar instanceof HTMLElement ? formulaBar : null;
+}
+function selectSpreadsheetFormulaBarContents(event) {
+    const formulaBar = spreadsheetFormulaBarSelectAllTarget(event);
+    const selection = window.getSelection();
+    if (!formulaBar || !selection) return false;
+    const range = document.createRange();
+    range.selectNodeContents(formulaBar);
+    selection.removeAllRanges();
+    selection.addRange(range);
+    return true;
+}
+function spreadsheetColumnLabel(column) {
+    let value = Math.max(0, column) + 1;
+    let label = '';
+    while(value > 0){
+        value -= 1;
+        label = String.fromCharCode(65 + value % 26) + label;
+        value = Math.floor(value / 26);
+    }
+    return label;
+}
+function spreadsheet_editor_support_spreadsheetCellHasContent(cell) {
+    if ('string' == typeof cell.f && cell.f.trim()) return true;
+    if (null === cell.v || void 0 === cell.v) return false;
+    return 'string' != typeof cell.v || cell.v.trim().length > 0;
+}
+function finiteSpreadsheetSelectionAxis(axis) {
+    const first = finiteSpreadsheetIndex(axis?.[0], 0);
+    const second = finiteSpreadsheetIndex(axis?.[1], first);
+    return [
+        Math.min(first, second),
+        Math.max(first, second)
+    ];
+}
+function finiteSpreadsheetFocus(value, axis) {
+    const focus = finiteSpreadsheetIndex(value, axis[0] ?? 0);
+    return Math.min(axis[1] ?? focus, Math.max(axis[0] ?? focus, focus));
+}
+function finiteSpreadsheetIndex(value, fallback) {
+    return 'number' == typeof value && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : fallback;
+}
+function spreadsheet_editor_support_isSpreadsheetCoordinate(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function spreadsheet_editor_support_spreadsheetSheetsById(sheets) {
+    const byId = new Map();
+    for (const sheet of sheets){
+        if (!sheet.id || byId.has(sheet.id)) return null;
+        byId.set(sheet.id, sheet);
+    }
+    return byId;
+}
+function spreadsheetSheetMetadata(sheet) {
+    if (!sheet) return null;
+    const { celldata: _cellData, calcChain: _calculationChain, data: _data, dynamicArray_compute: _dynamicArrayComputation, luckysheet_select_save: _selection, luckysheet_selection_range: _range, zoomRatio, ...content } = sheet;
+    return {
+        ...content,
+        ...void 0 === zoomRatio || 1 === zoomRatio ? {} : {
+            zoomRatio
+        }
+    };
+}
+function sameSpreadsheetSheetState(left, right) {
+    return Boolean(right && sameSpreadsheetHistoryValue(spreadsheetSheetMetadata(left), spreadsheetSheetMetadata(right)) && sameSpreadsheetCellStorage(left, right));
+}
+function sameSpreadsheetCellStorage(left, right) {
+    if (void 0 !== left.data && void 0 !== right.data) {
+        const leftProfile = spreadsheetMatrixProfile(left.data);
+        const rightProfile = spreadsheetMatrixProfile(right.data);
+        if (leftProfile && rightProfile && leftProfile.historyRoot === rightProfile.historyRoot) return leftProfile.historyState === rightProfile.historyState;
+        return sameSpreadsheetDataMatrices(left.data, right.data);
+    }
+    if (void 0 === left.data && void 0 === right.data) {
+        if (left.celldata === right.celldata) return true;
+    }
+    return sameSpreadsheetHistoryValue(spreadsheetPopulatedCellData(left), spreadsheetPopulatedCellData(right));
+}
+function sameSpreadsheetDataMatrices(left, right) {
+    if (left === right) return true;
+    for (const rowIndex of sparseArrayIndexes(left))if (!sameSpreadsheetDataRows(left[rowIndex], right[rowIndex])) return false;
+    for (const rowIndex of sparseArrayIndexes(right))if (!Object.hasOwn(left, rowIndex) && !sameSpreadsheetDataRows(void 0, right[rowIndex])) return false;
+    return true;
+}
+function sameSpreadsheetDataRows(left, right) {
+    if (left === right) return true;
+    for (const columnIndex of sparseArrayIndexes(left ?? [])){
+        const leftCell = left?.[columnIndex];
+        if (null == leftCell) continue;
+        const rightCell = right?.[columnIndex];
+        if (null == rightCell || !sameSpreadsheetHistoryValue(leftCell, rightCell)) return false;
+    }
+    for (const columnIndex of sparseArrayIndexes(right ?? []))if (right?.[columnIndex] != null && left?.[columnIndex] == null) return false;
+    return true;
+}
+function spreadsheetPopulatedCellData(sheet) {
+    const cells = [];
+    if (void 0 !== sheet.data) for (const rowIndex of sparseArrayIndexes(sheet.data)){
+        const row = sheet.data[rowIndex];
+        if (row) for (const columnIndex of sparseArrayIndexes(row)){
+            const cell = row[columnIndex];
+            if (null != cell) cells.push({
+                r: rowIndex,
+                c: columnIndex,
+                v: cell
+            });
+        }
+    }
+    else for (const cell of sheet.celldata ?? [])if (null != cell.v) cells.push(cell);
+    return cells.sort((left, right)=>left.r - right.r || left.c - right.c);
+}
+function spreadsheet_editor_support_positiveSpreadsheetDimension(value) {
+    return 'number' == typeof value && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+const spreadsheetKeyboardPageRows = 20;
+const spreadsheetDefaultRows = 60;
+const spreadsheetDefaultColumns = 26;
+function moveSpreadsheetKeyboardSelection(sheet, selection, move, extend) {
+    const bounds = spreadsheetSheetBounds(sheet);
+    const current = normalizeSpreadsheetKeyboardSelection(selection, bounds);
+    let targetRow = current.rowFocus;
+    let targetColumn = current.columnFocus;
+    switch(move){
+        case 'up':
+            targetRow -= 1;
+            break;
+        case 'down':
+            targetRow += 1;
+            break;
+        case 'left':
+            targetColumn -= 1;
+            break;
+        case 'right':
+            targetColumn += 1;
+            break;
+        case 'next-cell':
+            if (targetColumn < bounds.lastColumn) targetColumn += 1;
+            else if (targetRow < bounds.lastRow) {
+                targetRow += 1;
+                targetColumn = 0;
+            }
+            break;
+        case 'previous-cell':
+            if (targetColumn > 0) targetColumn -= 1;
+            else if (targetRow > 0) {
+                targetRow -= 1;
+                targetColumn = bounds.lastColumn;
+            }
+            break;
+        case 'page-up':
+            targetRow -= spreadsheetKeyboardPageRows;
+            break;
+        case 'page-down':
+            targetRow += spreadsheetKeyboardPageRows;
+            break;
+        case 'row-start':
+            targetColumn = 0;
+            break;
+        case 'sheet-start':
+            targetRow = 0;
+            targetColumn = 0;
+            break;
+        case 'used-end':
+            {
+                const usedEnd = spreadsheetUsedRangeEnd(sheet);
+                targetRow = usedEnd.row;
+                targetColumn = usedEnd.column;
+                break;
+            }
+    }
+    targetRow = clampSpreadsheetIndex(targetRow, bounds.lastRow);
+    targetColumn = clampSpreadsheetIndex(targetColumn, bounds.lastColumn);
+    if (!extend) return {
+        row: [
+            targetRow,
+            targetRow
+        ],
+        column: [
+            targetColumn,
+            targetColumn
+        ],
+        row_focus: targetRow,
+        column_focus: targetColumn
+    };
+    const rowAnchor = selectionAnchor(current.startRow, current.endRow, current.rowFocus);
+    const columnAnchor = selectionAnchor(current.startColumn, current.endColumn, current.columnFocus);
+    return {
+        row: [
+            Math.min(rowAnchor, targetRow),
+            Math.max(rowAnchor, targetRow)
+        ],
+        column: [
+            Math.min(columnAnchor, targetColumn),
+            Math.max(columnAnchor, targetColumn)
+        ],
+        row_focus: targetRow,
+        column_focus: targetColumn
+    };
+}
+function scopeSpreadsheetKeyboardSelection(sheet, selection, scope) {
+    const bounds = spreadsheetSheetBounds(sheet);
+    const current = normalizeSpreadsheetKeyboardSelection(selection, bounds);
+    if ('column' === scope) return {
+        row: [
+            0,
+            bounds.lastRow
+        ],
+        column: [
+            current.columnFocus,
+            current.columnFocus
+        ],
+        row_focus: current.rowFocus,
+        column_focus: current.columnFocus
+    };
+    if ('row' === scope) return {
+        row: [
+            current.rowFocus,
+            current.rowFocus
+        ],
+        column: [
+            0,
+            bounds.lastColumn
+        ],
+        row_focus: current.rowFocus,
+        column_focus: current.columnFocus
+    };
+    return {
+        row: [
+            0,
+            bounds.lastRow
+        ],
+        column: [
+            0,
+            bounds.lastColumn
+        ],
+        row_focus: current.rowFocus,
+        column_focus: current.columnFocus
+    };
+}
+function isSpreadsheetGridKeyboardTarget(target) {
+    if (null === target) return true;
+    return target instanceof Element && Boolean(target.closest('.fortune-container'));
+}
+function runSpreadsheetSelectionMoveShortcut(event, canExecute, execute, move, extend) {
+    if (event.isComposing || isOfficeShortcutBlocked(event.target) || isSpreadsheetNativeTextUndoTarget(event.target) || !isSpreadsheetGridKeyboardTarget(event.target) || !canExecute(move, extend)) return false;
+    return execute(move, extend);
+}
+function runSpreadsheetSelectionScopeShortcut(event, canExecute, execute, scope) {
+    if (event.repeat || event.isComposing || isOfficeShortcutBlocked(event.target) || isSpreadsheetNativeTextUndoTarget(event.target) || !isSpreadsheetGridKeyboardTarget(event.target) || !canExecute(scope)) return false;
+    return execute(scope);
+}
+function spreadsheetSelectionContainsFocus(selection, focus) {
+    const firstRow = selection.row[0] ?? 0;
+    const secondRow = selection.row[1] ?? firstRow;
+    const firstColumn = selection.column[0] ?? 0;
+    const secondColumn = selection.column[1] ?? firstColumn;
+    return focus.row >= Math.min(firstRow, secondRow) && focus.row <= Math.max(firstRow, secondRow) && focus.column >= Math.min(firstColumn, secondColumn) && focus.column <= Math.max(firstColumn, secondColumn);
+}
+function spreadsheetSheetBounds(sheet) {
+    const dataRows = sheet.data?.length ?? 0;
+    const dataColumns = sparseMatrixColumnCount(sheet.data);
+    return {
+        lastRow: spreadsheet_keyboard_navigation_positiveSpreadsheetDimension(sheet.row, dataRows, spreadsheetDefaultRows) - 1,
+        lastColumn: spreadsheet_keyboard_navigation_positiveSpreadsheetDimension(sheet.column, dataColumns, spreadsheetDefaultColumns) - 1
+    };
+}
+function spreadsheet_keyboard_navigation_positiveSpreadsheetDimension(configured, dataDimension, fallback) {
+    const value = Number(configured);
+    if (Number.isFinite(value) && value > 0) return Math.max(1, Math.trunc(value));
+    if (dataDimension > 0) return dataDimension;
+    return fallback;
+}
+function spreadsheetUsedRangeEnd(sheet) {
+    const bounds = spreadsheetSheetBounds(sheet);
+    let row = 0;
+    let column = 0;
+    sheet.data?.forEach((cells, rowIndex)=>{
+        cells?.forEach((cell, columnIndex)=>{
+            if (!spreadsheetCellHasValue(cell)) return;
+            row = Math.max(row, rowIndex);
+            column = Math.max(column, columnIndex);
+        });
+    });
+    sheet.celldata?.forEach((cell)=>{
+        if (!spreadsheetCellHasValue(cell.v)) return;
+        row = Math.max(row, Number(cell.r) || 0);
+        column = Math.max(column, Number(cell.c) || 0);
+    });
+    return {
+        row: clampSpreadsheetIndex(row, bounds.lastRow),
+        column: clampSpreadsheetIndex(column, bounds.lastColumn)
+    };
+}
+function spreadsheetCellHasValue(cell) {
+    if (!cell) return false;
+    if ('string' == typeof cell.f && cell.f.trim()) return true;
+    const value = cell.v;
+    if (null != value) return 'string' != typeof value || value.trim().length > 0;
+    return 'string' == typeof cell.m && cell.m.trim().length > 0;
+}
+function normalizeSpreadsheetKeyboardSelection(selection, bounds) {
+    const firstRow = clampSpreadsheetIndex(selection.row[0], bounds.lastRow);
+    const secondRow = clampSpreadsheetIndex(selection.row[1] ?? firstRow, bounds.lastRow);
+    const firstColumn = clampSpreadsheetIndex(selection.column[0], bounds.lastColumn);
+    const secondColumn = clampSpreadsheetIndex(selection.column[1] ?? firstColumn, bounds.lastColumn);
+    const startRow = Math.min(firstRow, secondRow);
+    const endRow = Math.max(firstRow, secondRow);
+    const startColumn = Math.min(firstColumn, secondColumn);
+    const endColumn = Math.max(firstColumn, secondColumn);
+    return {
+        startRow,
+        endRow,
+        startColumn,
+        endColumn,
+        rowFocus: clampSpreadsheetIndex(selection.row_focus ?? secondRow, bounds.lastRow),
+        columnFocus: clampSpreadsheetIndex(selection.column_focus ?? secondColumn, bounds.lastColumn)
+    };
+}
+function clampSpreadsheetIndex(value, maximum) {
+    const numeric = Number(value);
+    const finite = Number.isFinite(numeric) ? Math.trunc(numeric) : 0;
+    return Math.min(maximum, Math.max(0, finite));
+}
+function selectionAnchor(start, end, focus) {
+    return focus === start ? end : start;
+}
+const spreadsheetMaximumRows = 1048576;
+const 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',
+        code: 'ambiguous-name'
+    };
+    if (!preferred.length && !qualified) return {
+        kind: 'match',
+        value: null
+    };
+    return {
+        kind: 'match',
+        value: preferred[0] ?? null
+    };
+}
+function spreadsheetGoToRangeIsBounded(sheet, range) {
+    const bounds = spreadsheetSheetBounds(sheet);
+    return range.row[0] >= 0 && range.row[1] < spreadsheetMaximumRows && range.row[1] <= bounds.lastRow && range.column[0] >= 0 && range.column[1] < spreadsheetMaximumColumns && range.column[1] <= bounds.lastColumn;
+}
+function spreadsheetGoToSuccess(resolved, source, name) {
+    const reference = formatSpreadsheetCellRanges([
+        resolved.range
+    ]);
+    return {
+        ok: true,
+        target: {
+            displayReference: `${quoteSpreadsheetSheetName(resolved.sheet.name)}!${reference}`,
+            name,
+            range: resolved.range,
+            selection: {
+                row: [
+                    ...resolved.range.row
+                ],
+                column: [
+                    ...resolved.range.column
+                ],
+                row_focus: resolved.range.row[0],
+                column_focus: resolved.range.column[0]
+            },
+            sheetId: resolved.sheet.id ?? '',
+            source
+        }
+    };
+}
+function spreadsheetGoToError(code) {
+    const messages = {
+        'ambiguous-name': '同一作用域中存在多个同名区域，无法确定定位目标。',
+        empty: '请输入单元格、连续区域或已定义名称。',
+        'hidden-sheet': '不能定位到隐藏工作表。',
+        'invalid-reference': '请输入有效的 A1 单元格、连续区域或已定义名称。',
+        'multiple-ranges': '一次只能定位到一个连续区域。',
+        'out-of-bounds': '引用超出了目标工作表的有效边界。',
+        'sheet-not-found': '找不到引用的工作表。',
+        'unsupported-name': '该名称不是可定位的连续单元格区域。'
+    };
+    return {
+        ok: false,
+        code,
+        message: messages[code]
+    };
+}
+function splitSpreadsheetQualifiedReference(value) {
+    let quoted = false;
+    let separator = -1;
+    for(let index = 0; index < value.length; index += 1){
+        const character = value[index];
+        if ("'" === character) {
+            if (quoted && "'" === value[index + 1]) {
+                index += 1;
+                continue;
+            }
+            quoted = !quoted;
+            continue;
+        }
+        if ('!' === character && !quoted) {
+            if (separator >= 0) return null;
+            separator = index;
+        }
+    }
+    if (quoted) return null;
+    if (separator < 0) return {
+        qualifier: null,
+        reference: value.trim()
+    };
+    const rawQualifier = value.slice(0, separator).trim();
+    const reference = value.slice(separator + 1).trim();
+    if (!rawQualifier || !reference) return null;
+    const qualifier = unquoteSpreadsheetSheetName(rawQualifier);
+    return qualifier ? {
+        qualifier,
+        reference
+    } : null;
+}
+function unquoteSpreadsheetSheetName(value) {
+    if (!value.startsWith("'")) return value.includes("'") ? null : value;
+    if (!value.endsWith("'") || value.length < 2) return null;
+    const inner = value.slice(1, -1);
+    for(let index = 0; index < inner.length; index += 1)if ("'" === inner[index]) {
+        if ("'" !== inner[index + 1]) return null;
+        index += 1;
+    }
+    return inner.replaceAll("''", "'");
+}
+function spreadsheetSheetByName(content, name) {
+    const normalized = name.trim().toLocaleLowerCase();
+    return content.sheets.find((sheet)=>sheet.name.trim().toLocaleLowerCase() === normalized);
+}
+function quoteSpreadsheetSheetName(name) {
+    return `'${name.replaceAll("'", "''")}'`;
+}
+const MAX_SPREADSHEET_DEPENDENT_LIST_FORMULA_LENGTH = 255;
+const MAX_SPREADSHEET_DEPENDENT_LIST_REFERENCE_CELLS = 1024;
+const MAX_SPREADSHEET_DEPENDENT_LIST_MATERIALIZED_CELLS = 10000;
+const DEPENDENT_LIST_PROJECTION_KEY = '__a3sDependentListProjection';
+function isSpreadsheetDependentListFormula(value) {
+    return 'string' == typeof value && /^=?\s*INDIRECT\s*\(/iu.test(value.trim());
+}
+function normalizeSpreadsheetDependentListFormula(value) {
+    const source = value.trim();
+    if (!source) return {
+        ok: false,
+        message: '动态下拉来源不能为空。'
+    };
+    if (Array.from(source).length > MAX_SPREADSHEET_DEPENDENT_LIST_FORMULA_LENGTH) return {
+        ok: false,
+        message: '动态下拉公式超过 255 个字符。'
+    };
+    if (/[\u0000-\u001f\u007f]/u.test(source) || /[\[\]]/u.test(source)) return {
+        ok: false,
+        message: '动态下拉公式只能引用当前工作簿。'
+    };
+    const body = source.replace(/^=/, '').trim();
+    const argument = indirectArgument(body);
+    if (null === argument) return {
+        ok: false,
+        message: '动态下拉公式仅支持 =INDIRECT(单元格或文本拼接)。'
+    };
+    const terms = splitConcatenation(argument);
+    if (!terms || 0 === terms.length || terms.length > 16) return {
+        ok: false,
+        message: '动态下拉公式的拼接项数量超出本地安全边界。'
+    };
+    if (!terms.every((term)=>isDependentListTerm(term))) return {
+        ok: false,
+        message: '动态下拉公式只能拼接文本和单元格引用。'
+    };
+    return {
+        ok: true,
+        formula: `=INDIRECT(${terms.map((term)=>term.trim()).join('&')})`
+    };
+}
+function resolveSpreadsheetDependentListReference(content, sheetId, row, column, anchorRow, anchorColumn, formula) {
+    const normalized = normalizeSpreadsheetDependentListFormula(formula);
+    if (!normalized.ok || !normalized.formula) return {
+        ok: false,
+        message: normalized.message
+    };
+    const body = normalized.formula.slice(1);
+    const argument = indirectArgument(body);
+    if (null === argument) return {
+        ok: false,
+        message: '动态下拉公式括号不完整。'
+    };
+    const terms = splitConcatenation(argument);
+    if (!terms) return {
+        ok: false,
+        message: '动态下拉公式拼接项无效。'
+    };
+    let referenceText = '';
+    for (const term of terms){
+        const parsed = parseDependentListTerm(term.trim());
+        if (!parsed) return {
+            ok: false,
+            message: '动态下拉公式包含不支持的表达式。'
+        };
+        if ('text' === parsed.kind) {
+            referenceText += parsed.value;
+            continue;
+        }
+        const resolvedCell = resolveDependentListCell(content, sheetId, row, column, anchorRow, anchorColumn, parsed);
+        if (!resolvedCell.ok) return resolvedCell;
+        referenceText += resolvedCell.value;
+    }
+    const trimmedReference = referenceText.trim();
+    if (!trimmedReference) return {
+        ok: true,
+        empty: true
+    };
+    const target = resolveSpreadsheetGoToTarget(content, sheetId, trimmedReference);
+    if (!target.ok) return {
+        ok: false,
+        message: `动态下拉来源无法解析：${target.message}`
+    };
+    const area = spreadsheetCellRangeArea(target.target.range);
+    if (target.target.range.row[0] !== target.target.range.row[1] && target.target.range.column[0] !== target.target.range.column[1]) return {
+        ok: false,
+        message: '动态下拉来源只能是一行或一列连续区域。'
+    };
+    if (area > MAX_SPREADSHEET_DEPENDENT_LIST_REFERENCE_CELLS) return {
+        ok: false,
+        message: `动态下拉来源最多读取 ${MAX_SPREADSHEET_DEPENDENT_LIST_REFERENCE_CELLS.toLocaleString('en-US')} 个单元格。`
+    };
+    return {
+        ok: true,
+        displayReference: target.target.displayReference
+    };
+}
+function materializeSpreadsheetDependentListsForFortune(sheets, namedRanges = []) {
+    const content = {
+        type: 'spreadsheet',
+        sheets: sheets.map((sheet)=>sheet),
+        namedRanges
+    };
+    return sheets.map((sheet)=>{
+        let dataVerification;
+        let dataValidationRanges;
+        let changed = false;
+        let materializationBudget = MAX_SPREADSHEET_DEPENDENT_LIST_MATERIALIZED_CELLS;
+        const direct = sheet.dataVerification;
+        if (direct) for (const [key, value] of Object.entries(direct)){
+            const coordinate = dependentListCoordinate(key);
+            const item = dependentListItem(value);
+            if (!coordinate || !item || !isSpreadsheetDependentListFormula(item.value1)) continue;
+            const range = dependentListAnchorRange(item, coordinate.row, coordinate.column);
+            const reference = resolveSpreadsheetDependentListReference(content, sheet.id ?? '', coordinate.row, coordinate.column, range.row[0], range.column[0], item.value1);
+            const projected = projectedDependentListItem(item, reference, 'direct');
+            dataVerification ??= {
+                ...direct
+            };
+            dataVerification[key] = projected;
+            changed = true;
+            materializationBudget = Math.max(0, materializationBudget - 1);
+        }
+        for (const [entryIndex, entry] of (sheet.dataValidationRanges ?? []).entries()){
+            if (!isSpreadsheetDependentListFormula(entry.item.value1)) continue;
+            const formula = entry.item.value1;
+            const projectedItem = {
+                ...entry.item,
+                value1: '',
+                [DEPENDENT_LIST_PROJECTION_KEY]: {
+                    kind: 'compact',
+                    formula
+                }
+            };
+            dataValidationRanges ??= [
+                ...sheet.dataValidationRanges ?? []
+            ];
+            dataValidationRanges[entryIndex] = {
+                ...entry,
+                item: projectedItem
+            };
+            changed = true;
+            for (const range of entry.ranges){
+                const area = spreadsheetCellRangeArea(range);
+                if (!(area > materializationBudget)) {
+                    materializationBudget -= area;
+                    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 key = `${row}_${column}`;
+                        if (direct && Object.hasOwn(direct, key)) continue;
+                        const reference = resolveSpreadsheetDependentListReference(content, sheet.id ?? '', row, column, range.row[0], range.column[0], entry.item.value1);
+                        dataVerification ??= {
+                            ...direct ?? {}
+                        };
+                        dataVerification[key] = projectedDependentListItem(entry.item, reference, 'compact');
+                        changed = true;
+                    }
+                }
+            }
+        }
+        return changed ? {
+            ...sheet,
+            dataVerification: dataVerification,
+            dataValidationRanges
+        } : sheet;
+    });
+}
+function restoreSpreadsheetDependentListProjections(sheets) {
+    return sheets.map((sheet)=>{
+        const direct = sheet.dataVerification;
+        let nextDirect;
+        if (direct) for (const [key, value] of Object.entries(direct)){
+            const item = dependentListItem(value);
+            const marker = item?.[DEPENDENT_LIST_PROJECTION_KEY];
+            if (marker) {
+                nextDirect ??= {
+                    ...direct
+                };
+                if ('compact' === marker.kind) delete nextDirect[key];
+                else {
+                    const { [DEPENDENT_LIST_PROJECTION_KEY]: _marker, ...rest } = item;
+                    nextDirect[key] = {
+                        ...rest,
+                        value1: marker.formula
+                    };
+                }
+            }
+        }
+        let nextRanges;
+        for (const [entryIndex, entry] of (sheet.dataValidationRanges ?? []).entries()){
+            const item = entry.item;
+            const marker = item[DEPENDENT_LIST_PROJECTION_KEY];
+            if (!marker) continue;
+            const { [DEPENDENT_LIST_PROJECTION_KEY]: _marker, ...rest } = item;
+            nextRanges ??= [
+                ...sheet.dataValidationRanges ?? []
+            ];
+            nextRanges[entryIndex] = {
+                ...entry,
+                item: {
+                    ...rest,
+                    value1: marker.formula
+                }
+            };
+        }
+        if (!nextDirect && !nextRanges) return sheet;
+        return {
+            ...sheet,
+            dataVerification: nextDirect && Object.keys(nextDirect).length ? nextDirect : void 0,
+            dataValidationRanges: nextRanges
+        };
+    });
+}
+function projectedDependentListItem(item, reference, kind) {
+    const { [DEPENDENT_LIST_PROJECTION_KEY]: _previous, ...rest } = item;
+    return {
+        ...rest,
+        value1: reference.ok ? reference.displayReference ?? '' : '',
+        [DEPENDENT_LIST_PROJECTION_KEY]: {
+            kind,
+            formula: item.value1
+        }
+    };
+}
+function dependentListItem(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    if ('string' != typeof value.type) return null;
+    return value;
+}
+function dependentListCoordinate(value) {
+    const match = /^(\d+)_(\d+)$/.exec(value);
+    if (!match) return null;
+    const row = Number(match[1]);
+    const column = Number(match[2]);
+    return Number.isSafeInteger(row) && Number.isSafeInteger(column) ? {
+        row,
+        column
+    } : null;
+}
+function dependentListAnchorRange(item, row, column) {
+    const ranges = parseSpreadsheetCellRanges(item.rangeTxt);
+    const containing = ranges?.find((range)=>spreadsheetCellRangeContains(range, row, column));
+    return containing ? {
+        row: [
+            containing.row[0],
+            containing.row[0]
+        ],
+        column: [
+            containing.column[0],
+            containing.column[0]
+        ]
+    } : {
+        row: [
+            row,
+            row
+        ],
+        column: [
+            column,
+            column
+        ]
+    };
+}
+function indirectArgument(value) {
+    const match = /^INDIRECT\s*\(/iu.exec(value.trim());
+    if (!match) return null;
+    const start = match[0].length;
+    let depth = 1;
+    let quoted = false;
+    for(let index = start; index < value.length; index += 1){
+        const character = value[index];
+        if ('"' === character) {
+            if (quoted && '"' === value[index + 1]) {
+                index += 1;
+                continue;
+            }
+            quoted = !quoted;
+            continue;
+        }
+        if (!quoted) {
+            if ('(' === character) depth += 1;
+            if (')' === character) {
+                depth -= 1;
+                if (0 === depth) return value.slice(start, index).trim() && !value.slice(index + 1).trim() ? value.slice(start, index).trim() : null;
+            }
+        }
+    }
+    return null;
+}
+function splitConcatenation(value) {
+    const terms = [];
+    let start = 0;
+    let quoted = false;
+    for(let index = 0; index < value.length; index += 1){
+        const character = value[index];
+        if ('"' === character) {
+            if (quoted && '"' === value[index + 1]) {
+                index += 1;
+                continue;
+            }
+            quoted = !quoted;
+        } else if (quoted || '&' !== character) {
+            if (!quoted && ('(' === character || ')' === character)) return null;
+        } else {
+            terms.push(value.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    if (quoted) return null;
+    terms.push(value.slice(start).trim());
+    return terms;
+}
+function isDependentListTerm(value) {
+    return Boolean(parseDependentListTerm(value));
+}
+function parseDependentListTerm(value) {
+    const text = value.trim();
+    if (text.startsWith('"') && text.endsWith('"')) {
+        const inner = text.slice(1, -1);
+        for(let index = 0; index < inner.length; index += 1)if ('"' === inner[index]) {
+            if ('"' === inner[index + 1]) {
+                index += 1;
+                continue;
+            }
+            return null;
+        }
+        return {
+            kind: 'text',
+            value: inner.replaceAll('""', '"')
+        };
+    }
+    const match = /^(?:(?:'((?:[^']|'')+)'|([^'!\[\]\s]+))!)?(\$?)([A-Z]{1,3})(\$?)([1-9]\d*)$/iu.exec(text);
+    if (!match) return null;
+    const column = decodeColumn(match[4]);
+    const row = Number(match[6]) - 1;
+    if (column < 0 || row < 0 || column >= 16384 || row >= 1048576) return null;
+    return {
+        kind: 'cell',
+        qualifier: match[1] ? match[1].replaceAll("''", "'") : match[2],
+        column,
+        row,
+        absoluteColumn: Boolean(match[3]),
+        absoluteRow: Boolean(match[5])
+    };
+}
+function resolveDependentListCell(content, sheetId, row, column, anchorRow, anchorColumn, term) {
+    const fallback = content.sheets.find((sheet)=>sheet.id === sheetId);
+    const sheet = term.qualifier ? content.sheets.find((candidate)=>candidate.name.trim().toLocaleLowerCase() === term.qualifier?.trim().toLocaleLowerCase()) : fallback;
+    if (!sheet) return {
+        ok: false,
+        message: '动态下拉公式引用了不存在的工作表。'
+    };
+    const resolvedRow = term.absoluteRow ? term.row : row + (term.row - anchorRow);
+    const resolvedColumn = term.absoluteColumn ? term.column : column + (term.column - anchorColumn);
+    if (resolvedRow < 0 || resolvedColumn < 0 || resolvedRow >= 1048576 || resolvedColumn >= 16384) return {
+        ok: false,
+        message: '动态下拉公式引用超出了工作表边界。'
+    };
+    const cell = spreadsheetDependentListCellAt(sheet, resolvedRow, resolvedColumn);
+    if (!cell) return {
+        ok: true,
+        value: ''
+    };
+    if ('string' == typeof cell.f && cell.f && void 0 === cell.v) return {
+        ok: false,
+        message: '动态下拉公式引用了尚未计算的公式单元格。'
+    };
+    const displayed = cell.m ?? cell.v;
+    return {
+        ok: true,
+        value: null == displayed ? '' : String(displayed)
+    };
+}
+function spreadsheetDependentListCellAt(sheet, row, column) {
+    const direct = sheet.data?.[row]?.[column];
+    if (direct) return direct;
+    const entry = sheet.celldata?.find((candidate)=>candidate.r === row && candidate.c === column);
+    if (!entry || !entry.v || 'object' != typeof entry.v) return null;
+    return entry.v;
+}
+function decodeColumn(value) {
+    let result = 0;
+    for (const character of value.toUpperCase())result = 26 * result + character.charCodeAt(0) - 64;
+    return result - 1;
+}
 const A3S_DIAGONAL_BORDER_KEY = 'a3sDiagonal';
 function spreadsheetDiagonalBorderFromCellValue(value) {
-    if (!isRecord(value)) return;
+    if (!work_spreadsheet_diagonal_borders_isRecord(value)) return;
     const metadata = value[A3S_DIAGONAL_BORDER_KEY];
-    if (isRecord(metadata)) {
+    if (work_spreadsheet_diagonal_borders_isRecord(metadata)) {
         const up = metadata.up;
         const down = metadata.down;
         const line = spreadsheetDiagonalBorderLine(metadata.line);
@@ -3189,13 +7443,13 @@ function spreadsheetCellValueWithDiagonalBorder(value, border) {
     return next;
 }
 function spreadsheetDiagonalBorderLine(value) {
-    if (!isRecord(value)) return null;
+    if (!work_spreadsheet_diagonal_borders_isRecord(value)) return null;
     return 'string' == typeof value.color && 'string' == typeof value.style ? {
         color: value.color,
         style: value.style
     } : null;
 }
-function isRecord(value) {
+function work_spreadsheet_diagonal_borders_isRecord(value) {
     return Boolean(value && 'object' == typeof value && !Array.isArray(value));
 }
 const spreadsheetTextOrientationIds = [
@@ -3393,209 +7647,58 @@ function directXlsxFontStyle(cell) {
 }
 function directXlsxAlignment(cell) {
     const alignment = {};
-    if (void 0 !== cell.ht) alignment.horizontal = 0 === Number(cell.ht) ? 'center' : 2 === Number(cell.ht) ? 'right' : 'left';
-    if (void 0 !== cell.vt) alignment.vertical = 0 === Number(cell.vt) ? 'center' : 1 === Number(cell.vt) ? 'top' : 'bottom';
-    if (void 0 !== cell.tb) alignment.wrapText = '2' === cell.tb;
-    const rotation = spreadsheetTextOrientationXlsxValueFromCell(cell);
-    if (null !== rotation) alignment.textRotation = rotation;
-    return Object.keys(alignment).length ? alignment : null;
-}
-function xlsxStyleCollectionIndex(collection, childName, value) {
-    const index = nonNegativeInteger(value) ?? 0;
-    return directChildren(collection, childName)[index] ? index : 0;
-}
-function xlsxColorMatches(element, value, colors, fallback) {
-    const rgb = xlsxRgbColor(value);
-    const resolved = resolveXlsxColor(element, colors) ?? fallback;
-    return Boolean(rgb && resolved && `#${rgb.slice(-6).toLowerCase()}` === resolved.toLowerCase());
-}
-function xlsxToggleEnabled(element) {
-    if (!element) return false;
-    const value = attribute(element, 'val')?.trim().toLowerCase();
-    return '0' !== value && 'false' !== value && 'off' !== value;
-}
-function xlsxUnderlineStyle(element) {
-    return element ? spreadsheetUnderlineStyle(spreadsheetUnderlineCellValueFromXlsx(attribute(element, 'val'))) : 'none';
-}
-function xlsxBorderLineMatches(element, line, colors, semanticColor) {
-    const style = element ? attribute(element, 'style') : null;
-    if (!line) return !style;
-    return style === line.style && (semanticColor ? xlsxColorElementMatchesOrigin(element ? directChild(element, 'color') : void 0, semanticColor) : xlsxColorMatches(element ? directChild(element, 'color') : void 0, line.color, colors, '#000000'));
-}
-function activeXlsxSemanticColorOrigin(origin, value, palette) {
-    return origin && xlsxSemanticColorMatchesValue(origin, value) && xlsxSemanticColorOriginSupported(origin, palette) ? origin : void 0;
-}
-function xlsxBooleanAttribute(element, name) {
-    if (!element) return false;
-    const value = attribute(element, name)?.trim().toLowerCase();
-    return '1' === value || 'true' === value || 'on' === value;
-}
-function xlsxAlignmentMatches(xf, style) {
-    const alignment = directChild(xf, 'alignment');
-    if (void 0 !== style.horizontal && attribute(alignment ?? xf, 'horizontal') !== style.horizontal) return false;
-    if (void 0 !== style.vertical && attribute(alignment ?? xf, 'vertical') !== style.vertical) return false;
-    if (void 0 !== style.wrapText && (!alignment || null === attribute(alignment, 'wrapText') || xlsxBooleanAttribute(alignment, 'wrapText') !== style.wrapText)) return false;
-    if (void 0 !== style.textRotation) {
-        const rotation = nonNegativeInteger(alignment ? attribute(alignment, 'textRotation') : null);
-        if (rotation !== style.textRotation) return false;
-    }
-    return true;
-}
-function nonNegativeInteger(value) {
-    if (null === value || !/^\d+$/.test(value)) return null;
-    const parsed = Number(value);
-    return Number.isSafeInteger(parsed) ? parsed : null;
-}
-const xlsxNativeFillCellKeys = [
-    XLSX_PATTERN_FILL_CELL_KEY,
-    XLSX_GRADIENT_FILL_CELL_KEY
-];
-function activeXlsxNativeFill(cell) {
-    const gradient = activeXlsxGradientFill(cell);
-    const pattern = activeXlsxPatternFill(cell);
-    if (Boolean(gradient) === Boolean(pattern)) return;
-    return gradient ? {
-        kind: 'gradient',
-        value: gradient
-    } : {
-        kind: 'pattern',
-        value: pattern
-    };
-}
-function deleteXlsxNativeFills(cell) {
-    deleteXlsxGradientFill(cell);
-    deleteXlsxPatternFill(cell);
-}
-function xlsxNativeFillSemanticColors(fill) {
-    if (!fill) return [];
-    return 'gradient' === fill.kind ? xlsxGradientFillSemanticColors(fill.value) : xlsxPatternFillSemanticColors(fill.value);
-}
-function xlsxNativeFillKey(fill) {
-    if (!fill) return '';
-    return 'gradient' === fill.kind ? `gradient:${xlsxGradientFillKey(fill.value)}` : `pattern:${xlsxPatternFillKey(fill.value)}`;
-}
-const MAX_XLSX_RICH_TEXT_CELL_CHARACTERS = 32767;
-const MAX_XLSX_RICH_TEXT_RUNS_PER_CELL = 512;
-const MAX_XLSX_RICH_TEXT_FONT_NAME_CHARACTERS = 128;
-const MAX_XLSX_RICH_TEXT_FONT_SIZE = 409;
-function normalizeXlsxRichTextEditSource(cell) {
-    if (cell?.f) return null;
-    if (cell) {
-        const rich = normalizeXlsxRichTextCell(cell);
-        if (rich) return rich;
-    }
-    const text = cell?.v;
-    if (void 0 !== text && ('string' != typeof text || text.length > MAX_XLSX_RICH_TEXT_CELL_CHARACTERS || !validXlsxRichText(text))) return null;
-    const value = text ?? '';
-    return {
-        runs: value ? [
-            xlsxRichTextBaseRun(cell, value)
-        ] : [],
-        text: value
-    };
-}
-function xlsxRichTextBaseRun(cell, text) {
-    const run = {
-        v: text
-    };
-    if (1 === Number(cell?.bl)) run.bl = 1;
-    if (1 === Number(cell?.it)) run.it = 1;
-    if (1 === Number(cell?.cl)) run.cl = 1;
-    const underline = Number(cell?.un);
-    if (Number.isSafeInteger(underline) && underline >= 1 && underline <= 4) run.un = underline;
-    if ('string' == typeof cell?.ff && cell.ff.trim() && cell.ff.trim().length <= MAX_XLSX_RICH_TEXT_FONT_NAME_CHARACTERS) run.ff = cell.ff.trim();
-    const size = Number(cell?.fs);
-    if (Number.isFinite(size) && size >= 1 && size <= MAX_XLSX_RICH_TEXT_FONT_SIZE) run.fs = size;
-    const color = normalizeXlsxRichTextColor(cell?.fc);
-    if (color) {
-        run.fc = color;
-        const origin = normalizeXlsxSemanticColorOrigin(xlsxCellStyleOrigin(cell ?? {})?.fontColor);
-        if (origin && xlsxSemanticColorMatchesValue(origin, color)) run.a3sXlsxColorOrigin = origin;
-    }
-    return run;
-}
-function normalizeXlsxRichTextCell(cell) {
-    if (cell.f || cell.ct?.t !== 'inlineStr' || !Array.isArray(cell.ct.s)) return null;
-    if (!cell.ct.s.length || cell.ct.s.length > MAX_XLSX_RICH_TEXT_RUNS_PER_CELL) return null;
-    const runs = [];
-    let characterCount = 0;
-    for (const candidate of cell.ct.s){
-        const run = normalizeXlsxRichTextRun(candidate);
-        if (!run) return null;
-        if (run.v) {
-            characterCount += run.v.length;
-            if (characterCount > MAX_XLSX_RICH_TEXT_CELL_CHARACTERS) return null;
-            runs.push(run);
-        }
-    }
-    const text = runs.map((run)=>run.v).join('');
-    return runs.length && text ? {
-        runs,
-        text
-    } : null;
-}
-function normalizeXlsxRichTextRun(value) {
-    if (!work_xlsx_rich_text_model_isRecord(value) || 'string' != typeof value.v || !validXlsxRichText(value.v)) return null;
-    const run = {
-        v: value.v
-    };
-    copyToggle(value, run, 'bl');
-    copyToggle(value, run, 'it');
-    copyToggle(value, run, 'cl');
-    if ('string' == typeof value.ff && value.ff.trim() && value.ff.trim().length <= MAX_XLSX_RICH_TEXT_FONT_NAME_CHARACTERS) run.ff = value.ff.trim();
-    if ('number' == typeof value.fs && Number.isFinite(value.fs) && value.fs >= 1 && value.fs <= MAX_XLSX_RICH_TEXT_FONT_SIZE) run.fs = value.fs;
-    const color = normalizeXlsxRichTextColor(value.fc);
-    if (color) run.fc = color;
-    const underline = Number(value.un);
-    if (Number.isSafeInteger(underline) && underline >= 0 && underline <= 4 && void 0 !== value.un) run.un = underline;
-    const colorOrigin = normalizeXlsxSemanticColorOrigin(value.a3sXlsxColorOrigin);
-    if (colorOrigin) run.a3sXlsxColorOrigin = colorOrigin;
-    return run;
+    if (void 0 !== cell.ht) alignment.horizontal = 0 === Number(cell.ht) ? 'center' : 2 === Number(cell.ht) ? 'right' : 'left';
+    if (void 0 !== cell.vt) alignment.vertical = 0 === Number(cell.vt) ? 'center' : 1 === Number(cell.vt) ? 'top' : 'bottom';
+    if (void 0 !== cell.tb) alignment.wrapText = '2' === cell.tb;
+    const rotation = spreadsheetTextOrientationXlsxValueFromCell(cell);
+    if (null !== rotation) alignment.textRotation = rotation;
+    return Object.keys(alignment).length ? alignment : null;
 }
-function normalizeXlsxRichTextColor(value) {
+function xlsxStyleCollectionIndex(collection, childName, value) {
+    const index = nonNegativeInteger(value) ?? 0;
+    return directChildren(collection, childName)[index] ? index : 0;
+}
+function xlsxColorMatches(element, value, colors, fallback) {
     const rgb = xlsxRgbColor(value);
-    return rgb ? `#${rgb.slice(-6).toLowerCase()}` : null;
+    const resolved = resolveXlsxColor(element, colors) ?? fallback;
+    return Boolean(rgb && resolved && `#${rgb.slice(-6).toLowerCase()}` === resolved.toLowerCase());
 }
-function coalesceXlsxRichTextRuns(source) {
-    const result = [];
-    for (const run of source){
-        if (!run.v) continue;
-        const previous = result.at(-1);
-        if (previous && sameXlsxRichTextRunStyle(previous, run)) previous.v += run.v;
-        else result.push({
-            ...run
-        });
-    }
-    return result;
+function xlsxToggleEnabled(element) {
+    if (!element) return false;
+    const value = attribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
 }
-function sameXlsxRichTextRunStyle(left, right) {
-    return left.bl === right.bl && left.cl === right.cl && left.fc === right.fc && left.ff === right.ff && left.fs === right.fs && left.it === right.it && left.un === right.un && JSON.stringify(left.a3sXlsxColorOrigin) === JSON.stringify(right.a3sXlsxColorOrigin);
+function xlsxUnderlineStyle(element) {
+    return element ? spreadsheetUnderlineStyle(spreadsheetUnderlineCellValueFromXlsx(attribute(element, 'val'))) : 'none';
 }
-function validXlsxRichText(value) {
-    for(let index = 0; index < value.length; index += 1){
-        const code = value.charCodeAt(index);
-        if (0x09 !== code && 0x0a !== code && 0x0d !== code && (!(code >= 0x20) || !(code <= 0xd7ff)) && (!(code >= 0xe000) || !(code <= 0xfffd))) {
-            if (isHighSurrogate(code) && index + 1 < value.length && isLowSurrogate(value.charCodeAt(index + 1))) {
-                index += 1;
-                continue;
-            }
-            return false;
-        }
-    }
-    return true;
+function xlsxBorderLineMatches(element, line, colors, semanticColor) {
+    const style = element ? attribute(element, 'style') : null;
+    if (!line) return !style;
+    return style === line.style && (semanticColor ? xlsxColorElementMatchesOrigin(element ? directChild(element, 'color') : void 0, semanticColor) : xlsxColorMatches(element ? directChild(element, 'color') : void 0, line.color, colors, '#000000'));
 }
-function isHighSurrogate(value) {
-    return value >= 0xd800 && value <= 0xdbff;
+function activeXlsxSemanticColorOrigin(origin, value, palette) {
+    return origin && xlsxSemanticColorMatchesValue(origin, value) && xlsxSemanticColorOriginSupported(origin, palette) ? origin : void 0;
 }
-function isLowSurrogate(value) {
-    return value >= 0xdc00 && value <= 0xdfff;
+function xlsxBooleanAttribute(element, name) {
+    if (!element) return false;
+    const value = attribute(element, name)?.trim().toLowerCase();
+    return '1' === value || 'true' === value || 'on' === value;
 }
-function copyToggle(source, target, key) {
-    if (1 === Number(source[key])) target[key] = 1;
-    else if (0 === Number(source[key]) && void 0 !== source[key]) target[key] = 0;
+function xlsxAlignmentMatches(xf, style) {
+    const alignment = directChild(xf, 'alignment');
+    if (void 0 !== style.horizontal && attribute(alignment ?? xf, 'horizontal') !== style.horizontal) return false;
+    if (void 0 !== style.vertical && attribute(alignment ?? xf, 'vertical') !== style.vertical) return false;
+    if (void 0 !== style.wrapText && (!alignment || null === attribute(alignment, 'wrapText') || xlsxBooleanAttribute(alignment, 'wrapText') !== style.wrapText)) return false;
+    if (void 0 !== style.textRotation) {
+        const rotation = nonNegativeInteger(alignment ? attribute(alignment, 'textRotation') : null);
+        if (rotation !== style.textRotation) return false;
+    }
+    return true;
 }
-function work_xlsx_rich_text_model_isRecord(value) {
-    return 'object' == typeof value && null !== value && !Array.isArray(value);
+function nonNegativeInteger(value) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
 }
 const MAX_XLSX_SHARED_RICH_TEXT_ITEMS = 10000;
 function createXlsxRichTextReadContext(options) {
@@ -3733,11 +7836,11 @@ function writeXlsxRichTextCells(worksheet, sheet, semanticPalette) {
         }
     }
 }
-function readRichSharedStrings(document, colors) {
-    if (!document) return new Map();
+function readRichSharedStrings(document1, colors) {
+    if (!document1) return new Map();
     const result = new Map();
     let parsedRuns = 0;
-    for (const [index, item] of directChildren(document.documentElement, 'si').entries()){
+    for (const [index, item] of directChildren(document1.documentElement, 'si').entries()){
         if (result.size >= MAX_XLSX_SHARED_RICH_TEXT_ITEMS || parsedRuns >= 100000) break;
         const runs = readRichTextRuns(item, colors);
         if (runs && !(parsedRuns + runs.length > 100000)) {
@@ -3795,14 +7898,14 @@ function readRichTextRun(element, value, colors) {
 function writeRichTextCell(element, richText, semanticPalette) {
     for (const child of directChildren(element))if ('v' === child.localName || 'is' === child.localName) child.remove();
     element.setAttribute('t', 'inlineStr');
-    const document = element.ownerDocument;
-    const namespace = document.documentElement.namespaceURI;
-    const inlineString = document.createElementNS(namespace, 'is');
+    const document1 = element.ownerDocument;
+    const namespace = document1.documentElement.namespaceURI;
+    const inlineString = document1.createElementNS(namespace, 'is');
     for (const run of richText.runs){
-        const runElement = document.createElementNS(namespace, 'r');
-        const properties = writeRichTextRunProperties(document, run, semanticPalette);
+        const runElement = document1.createElementNS(namespace, 'r');
+        const properties = writeRichTextRunProperties(document1, run, semanticPalette);
         if (properties) runElement.append(properties);
-        const text = document.createElementNS(namespace, 't');
+        const text = document1.createElementNS(namespace, 't');
         if (/^\s|\s$/.test(run.v)) text.setAttributeNS('http://www.w3.org/XML/1998/namespace', 'xml:space', 'preserve');
         text.textContent = run.v;
         runElement.append(text);
@@ -3810,17 +7913,17 @@ function writeRichTextCell(element, richText, semanticPalette) {
     }
     element.insertBefore(inlineString, directChildren(element).find((child)=>'extLst' === child.localName) ?? null);
 }
-function writeRichTextRunProperties(document, run, semanticPalette) {
-    const namespace = document.documentElement.namespaceURI;
-    const properties = document.createElementNS(namespace, 'rPr');
+function writeRichTextRunProperties(document1, run, semanticPalette) {
+    const namespace = document1.documentElement.namespaceURI;
+    const properties = document1.createElementNS(namespace, 'rPr');
     const appendValue = (name, value)=>{
-        const element = document.createElementNS(namespace, name);
+        const element = document1.createElementNS(namespace, name);
         element.setAttribute('val', value);
         properties.append(element);
     };
     const appendToggle = (name, enabled)=>{
         if (!enabled) return;
-        const element = document.createElementNS(namespace, name);
+        const element = document1.createElementNS(namespace, name);
         element.setAttribute('val', '1');
         properties.append(element);
     };
@@ -3829,7 +7932,7 @@ function writeRichTextRunProperties(document, run, semanticPalette) {
     appendToggle('i', 1 === run.it);
     appendToggle('strike', 1 === run.cl);
     if (run.fc) {
-        const color = document.createElementNS(namespace, 'color');
+        const color = document1.createElementNS(namespace, 'color');
         const semanticOrigin = activeXlsxSemanticColorOrigin(normalizeXlsxSemanticColorOrigin(run.a3sXlsxColorOrigin), run.fc, semanticPalette);
         if (semanticOrigin) applyXlsxSemanticColorOrigin(color, semanticOrigin);
         else {
@@ -3863,184 +7966,6 @@ function work_xlsx_rich_text_nonNegativeInteger(value) {
 function work_xlsx_rich_text_isRecord(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
 }
-const MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRIES = 256;
-const MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRY_CODE_POINTS = 128;
-const MAX_SPREADSHEET_SORT_CUSTOM_LIST_CODE_POINTS = 4096;
-const MAX_SPREADSHEET_SORT_USER_CUSTOM_LISTS = 32;
-function parseSpreadsheetSortCustomList(text) {
-    return validateSpreadsheetSortCustomList(text.split(/\r?\n|,|，/u).map((entry)=>entry.trim()).filter(Boolean));
-}
-function validateSpreadsheetSortCustomList(input) {
-    if (!Array.isArray(input)) return customListError('invalid-entry');
-    if (input.length < 2) return customListError('not-enough-entries');
-    if (input.length > MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRIES) return customListError('too-many-entries');
-    const entries = [];
-    const seen = new Set();
-    let totalCodePoints = 0;
-    for (const candidate of input){
-        if ('string' != typeof candidate) return customListError('invalid-entry');
-        const entry = candidate.trim();
-        if (!entry) return customListError('invalid-entry');
-        const codePoints = Array.from(entry).length;
-        if (codePoints > MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRY_CODE_POINTS) return customListError('entry-too-long');
-        totalCodePoints += codePoints;
-        if (totalCodePoints > MAX_SPREADSHEET_SORT_CUSTOM_LIST_CODE_POINTS) return customListError('list-too-long');
-        const matchKey = spreadsheetSortCustomListMatchKey(entry);
-        if (seen.has(matchKey)) return customListError('duplicate-entry');
-        seen.add(matchKey);
-        entries.push(entry);
-    }
-    return {
-        ok: true,
-        entries
-    };
-}
-function createSpreadsheetSortCustomList(entries, source = 'session') {
-    const validation = validateSpreadsheetSortCustomList(entries);
-    if (!validation.ok) return null;
-    const normalized = Object.freeze([
-        ...validation.entries
-    ]);
-    return Object.freeze({
-        source,
-        entries: normalized,
-        label: spreadsheetSortCustomListLabel(normalized)
-    });
-}
-function mergeSpreadsheetSortCustomLists(lists) {
-    const merged = [
-        ...SPREADSHEET_SORT_BUILT_IN_CUSTOM_LISTS
-    ];
-    let userListCount = 0;
-    for (const candidate of lists){
-        if ('stored' !== candidate.source && 'session' !== candidate.source) continue;
-        const list = createSpreadsheetSortCustomList(candidate.entries, candidate.source);
-        if (!(!list || merged.some((item)=>spreadsheetSortCustomListsEqual(item.entries, list.entries)))) {
-            if (userListCount >= MAX_SPREADSHEET_SORT_USER_CUSTOM_LISTS) break;
-            merged.push(list);
-            userListCount += 1;
-        }
-    }
-    return Object.freeze(merged);
-}
-function spreadsheetSortCustomListsEqual(left, right) {
-    return left.length === right.length && left.every((entry, index)=>spreadsheetSortCustomListMatchKey(entry) === spreadsheetSortCustomListMatchKey(right[index] ?? ''));
-}
-function spreadsheetSortCustomListMatchKey(value) {
-    return String(value).normalize('NFKC').trim().toLocaleLowerCase('zh-CN');
-}
-function spreadsheetSortCustomListLabel(entries) {
-    const visible = entries.slice(0, 3).map((entry)=>truncateSpreadsheetSortCustomListLabelEntry(entry));
-    return `${visible.join(' → ')}${entries.length > 3 ? ' → …' : ''}`;
-}
-function truncateSpreadsheetSortCustomListLabelEntry(entry) {
-    const characters = Array.from(entry);
-    return characters.length > 18 ? `${characters.slice(0, 17).join('')}…` : entry;
-}
-function customListError(code) {
-    const messages = {
-        'duplicate-entry': '自定义序列不能包含重复项（忽略大小写和全半角差异）。',
-        'entry-too-long': `每个序列项最多包含 ${MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRY_CODE_POINTS} 个字符。`,
-        'invalid-entry': '自定义序列只能包含非空文本项。',
-        'list-too-long': `一个自定义序列最多包含 ${MAX_SPREADSHEET_SORT_CUSTOM_LIST_CODE_POINTS.toLocaleString('en-US')} 个字符。`,
-        'not-enough-entries': '自定义序列至少需要两个项目。',
-        'too-many-entries': `一个自定义序列最多包含 ${MAX_SPREADSHEET_SORT_CUSTOM_LIST_ENTRIES} 个项目。`
-    };
-    return {
-        ok: false,
-        code,
-        message: messages[code]
-    };
-}
-function builtInCustomList(label, entries) {
-    return Object.freeze({
-        source: 'built-in',
-        entries: Object.freeze([
-            ...entries
-        ]),
-        label
-    });
-}
-const SPREADSHEET_SORT_BUILT_IN_CUSTOM_LISTS = Object.freeze([
-    builtInCustomList('月份（一月 → 十二月）', [
-        '一月',
-        '二月',
-        '三月',
-        '四月',
-        '五月',
-        '六月',
-        '七月',
-        '八月',
-        '九月',
-        '十月',
-        '十一月',
-        '十二月'
-    ]),
-    builtInCustomList('星期（星期日 → 星期六）', [
-        '星期日',
-        '星期一',
-        '星期二',
-        '星期三',
-        '星期四',
-        '星期五',
-        '星期六'
-    ]),
-    builtInCustomList('周（周日 → 周六）', [
-        '周日',
-        '周一',
-        '周二',
-        '周三',
-        '周四',
-        '周五',
-        '周六'
-    ]),
-    builtInCustomList('月份（January → December）', [
-        'January',
-        'February',
-        'March',
-        'April',
-        'May',
-        'June',
-        'July',
-        'August',
-        'September',
-        'October',
-        'November',
-        'December'
-    ]),
-    builtInCustomList('月份（Jan → Dec）', [
-        'Jan',
-        'Feb',
-        'Mar',
-        'Apr',
-        'May',
-        'Jun',
-        'Jul',
-        'Aug',
-        'Sep',
-        'Oct',
-        'Nov',
-        'Dec'
-    ]),
-    builtInCustomList('星期（Sunday → Saturday）', [
-        'Sunday',
-        'Monday',
-        'Tuesday',
-        'Wednesday',
-        'Thursday',
-        'Friday',
-        'Saturday'
-    ]),
-    builtInCustomList('星期（Sun → Sat）', [
-        'Sun',
-        'Mon',
-        'Tue',
-        'Wed',
-        'Thu',
-        'Fri',
-        'Sat'
-    ])
-]);
 const SPREADSHEET_SORT_CUSTOM_LIST_STORAGE_VERSION = 1;
 const DEFAULT_SPREADSHEET_SORT_CUSTOM_LIST_STORAGE_KEY = 'a3s-office.spreadsheet-sort-custom-lists.v1';
 class LocalStorageSpreadsheetSortCustomListStore {
@@ -4086,4 +8011,4 @@ function normalizeStoredSpreadsheetSortCustomLists(input) {
 function spreadsheet_sort_custom_list_store_isRecord(value) {
     return Boolean(value && 'object' == typeof value && !Array.isArray(value));
 }
-export { DEFAULT_SPREADSHEET_SORT_CUSTOM_LIST_STORAGE_KEY, LocalStorageSpreadsheetSortCustomListStore, SPREADSHEET_TABLE_TOTALS_FUNCTIONS, activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, coalesceXlsxRichTextRuns, createSpreadsheetSortCustomList, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, fillSpreadsheetTableCalculatedColumns, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isHighSurrogate, isLowSurrogate, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, mergeSpreadsheetSortCustomLists, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetTableCalculatedFormula, normalizeSpreadsheetTableTotalsFormula, normalizeSpreadsheetTableTotalsLabel, normalizeStoredSpreadsheetSortCustomLists, normalizeWorkSpreadsheetFilterCriteria, normalizeXlsxRichTextCell, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextRun, normalizedWorkSpreadsheetAutoFilterRange, parseSpreadsheetSortCustomList, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, reconcileSpreadsheetTableCalculatedColumns, reconcileSpreadsheetTableTotalsColumns, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sameXlsxRichTextRunStyle, sheetHasXlsxRichTextCells, spreadsheetCellValueWithDiagonalBorder, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetSortCustomListMatchKey, spreadsheetSortCustomListsEqual, spreadsheetTableTotalsColumnPatch, spreadsheetTableTotalsFunctionFromOoxml, spreadsheetTableTotalsFunctionLabel, spreadsheetTableTotalsFunctionToOoxml, spreadsheetTableTotalsRowHasContent, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, synchronizeSpreadsheetTableTotalsRow, validXlsxRichText, validateSpreadsheetSortCustomList, withDefaultSpreadsheetTableTotalsLabel, workSpreadsheetAutoFilterCriteria, workSpreadsheetAutoFilterCriteriaEntries, workSpreadsheetAutoFilterManuallyHiddenRows, workSpreadsheetAutoFilterOwnedRows, workSpreadsheetCellIsDate, workSpreadsheetFilterHiddenRows, workSpreadsheetFilterTextCharacters, workSpreadsheetHasUnescapedWildcard, workSpreadsheetSheetWithAutoFilterCriteria, workSpreadsheetSheetWithImportedAutoFilterCriteria, workSpreadsheetSheetWithReappliedAutoFilterCriteria, workSpreadsheetSheetWithoutAutoFilterCriteria, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };
+export { DEFAULT_SPREADSHEET_SORT_CUSTOM_LIST_STORAGE_KEY, LocalStorageSpreadsheetSortCustomListStore, MAX_SPREADSHEET_SORT_CELLS, SPREADSHEET_TABLE_TOTALS_FUNCTIONS, activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, canApplySpreadsheetTableStructureChange, captureSpreadsheetRichTextDomSelection, captureSpreadsheetRichTextPaste, coalesceXlsxRichTextRuns, createSpreadsheetSortAppearanceRows, createSpreadsheetSortCustomList, createSpreadsheetSortDialogSource, createSpreadsheetSortDirectAppearanceRows, createSpreadsheetSortRangeDialogSource, createSpreadsheetSortRangePlan, createSpreadsheetSortTextComparator, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, evaluateSpreadsheetLocalFormula, finiteSpreadsheetSelection, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isSpreadsheetCellEditingTarget, isSpreadsheetCellEditorTarget, isSpreadsheetDependentListFormula, isSpreadsheetGridKeyboardTarget, isSpreadsheetNativeTextUndoTarget, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, mergeSpreadsheetSortCustomLists, moveSpreadsheetKeyboardSelection, nextSpreadsheetFontSize, normalizeSpreadsheetCellFillFormat, normalizeSpreadsheetCellRange, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetDependentListFormula, normalizeSpreadsheetTableCalculatedFormula, normalizeSpreadsheetTableTotalsFormula, normalizeSpreadsheetTableTotalsLabel, normalizeStoredSpreadsheetSortCustomLists, normalizeWorkSpreadsheetFilterCriteria, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizedWorkSpreadsheetAutoFilterRange, parseSpreadsheetCellRange, parseSpreadsheetSortAppearanceTargetValue, parseSpreadsheetSortCustomList, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, reconcileSpreadsheetFiltersAfterSort, reconcileSpreadsheetTableCalculatedColumns, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, resolveSpreadsheetDependentListReference, resolveSpreadsheetGoToTarget, runSpreadsheetSelectionMoveShortcut, runSpreadsheetSelectionScopeShortcut, sameSpreadsheetHistoryContent, sameSpreadsheetWorkbookState, sameSpreadsheetWorkbookStateAfterOperations, scopeSpreadsheetKeyboardSelection, selectSpreadsheetFormulaBarContents, sheetHasXlsxRichTextCells, spreadsheetCellFillFormat, spreadsheetCellRangeArea, spreadsheetCellRangeContains, spreadsheetCellRangesEqual, spreadsheetCellRangesIntersect, spreadsheetCellValueWithDiagonalBorder, spreadsheetConditionalFormatStyles, spreadsheetContentWithSelection, spreadsheetContentWithSelections, spreadsheetCurrentRegion, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetFilterReconciliationIsBounded, spreadsheetFontFamilyOptions, spreadsheetFontSizeOptions, spreadsheetGoToValidationMessage, spreadsheetLocalFormulaBoolean, spreadsheetRowHasContent, spreadsheetSelectionContainsFocus, spreadsheetSelectionReference, spreadsheetSelectionSummary, spreadsheetSheetBounds, spreadsheetSheetCellReader, spreadsheetSheetsForFortune, spreadsheetSheetsFromFortune, spreadsheetSheetsWithFiniteSelections, spreadsheetSingleRange, spreadsheetSortAppearanceFields, spreadsheetSortAppearanceRowsMatch, spreadsheetSortAppearanceTargetLabel, spreadsheetSortAppearanceTargetValue, spreadsheetSortAppearanceTargets, spreadsheetSortAppearanceTargetsEqual, spreadsheetSortCellMatchesAppearance, spreadsheetSortCustomListMatchKey, spreadsheetSortCustomListsEqual, spreadsheetSortError, spreadsheetSortOwnedRangeForExactRange, spreadsheetSortRowsFromSheet, spreadsheetSortRowsMatchRange, spreadsheetTableTotalsColumnPatch, spreadsheetTableTotalsFunctionFromOoxml, spreadsheetTableTotalsFunctionLabel, spreadsheetTableTotalsFunctionToOoxml, spreadsheetTableTotalsRowHasContent, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, spreadsheet_editor_support_spreadsheetCellAt, subtractSpreadsheetCellRange, synchronizeSpreadsheetTableTotalsRow, validateSpreadsheetSortRequest, withDefaultSpreadsheetTableTotalsLabel, withSpreadsheetCellFillFormat, workSpreadsheetAutoFilterCriteria, workSpreadsheetAutoFilterCriteriaEntries, workSpreadsheetAutoFilterManuallyHiddenRows, workSpreadsheetCellIsDate, workSpreadsheetFilterTextCharacters, workSpreadsheetHasUnescapedWildcard, workSpreadsheetSheetWithAutoFilterCriteria, workSpreadsheetSheetWithImportedAutoFilterCriteria, workSpreadsheetSheetWithoutAutoFilterCriteria, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };