@a3s-lab/office 0.36.0 → 0.37.1

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

@@ -173,6 +173,340 @@ function nearestSpreadsheetTableCell(sheet, table, row, column) {
     }
     return null;
 }
+const MAX_SPREADSHEET_TABLE_TOTALS_FORMULA_LENGTH = 8192;
+const MAX_SPREADSHEET_TABLE_TOTALS_LABEL_LENGTH = 255;
+const DEFAULT_SPREADSHEET_TABLE_TOTALS_LABEL = 'Total';
+const SPREADSHEET_TABLE_TOTALS_FUNCTIONS = Object.freeze([
+    'sum',
+    'average',
+    'count',
+    'countNums',
+    'max',
+    'min',
+    'stdDev',
+    'stdDevP',
+    'var',
+    'varP',
+    'custom'
+]);
+const UNSAFE_TOTALS_FUNCTIONS = new Set([
+    'CALL',
+    'DDE',
+    'DDE.REQUEST',
+    'DDE.POKE',
+    'EXEC',
+    'HYPERLINK',
+    'INDIRECT',
+    'OFFSET',
+    'REGISTER.ID',
+    'RTD',
+    'WEBSERVICE'
+]);
+const SUBTOTAL_CODES = {
+    average: 101,
+    count: 103,
+    countNums: 102,
+    max: 104,
+    min: 105,
+    stdDev: 107,
+    stdDevP: 108,
+    sum: 109,
+    var: 110,
+    varP: 111
+};
+const OOXML_TOTALS_FUNCTIONS = {
+    average: 'average',
+    count: 'count',
+    countNums: 'countNums',
+    max: 'max',
+    min: 'min',
+    stdDev: 'stdDev',
+    stdDevP: 'stdDevp',
+    sum: 'sum',
+    var: 'var',
+    varP: 'varp'
+};
+const TOTALS_FUNCTION_LABELS = {
+    sum: '求和',
+    average: '平均值',
+    count: '计数',
+    countNums: '数值计数',
+    max: '最大值',
+    min: '最小值',
+    stdDev: '标准差',
+    stdDevP: '总体标准差',
+    var: '方差',
+    varP: '总体方差',
+    custom: '自定义'
+};
+function spreadsheetTableTotalsFunctionLabel(value) {
+    return value ? TOTALS_FUNCTION_LABELS[value] : '不汇总';
+}
+function normalizeSpreadsheetTableTotalsFunction(value) {
+    if ('string' != typeof value) return;
+    if ('none' === value || '' === value) return;
+    return SPREADSHEET_TABLE_TOTALS_FUNCTIONS.includes(value) ? value : void 0;
+}
+function normalizeSpreadsheetTableTotalsFormula(value) {
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    const formula = trimmed.startsWith('=') ? trimmed : `=${trimmed}`;
+    if (formula.startsWith('==') || formula.length > MAX_SPREADSHEET_TABLE_TOTALS_FORMULA_LENGTH || /[\u0000-\u001f\u007f]/u.test(formula) || formulaHasExternalReference(formula) || spreadsheetFormulaFunctions(formula).some((name)=>UNSAFE_TOTALS_FUNCTIONS.has(name))) return;
+    const editable = editableSpreadsheetFormula(formula).trim();
+    return editable || void 0;
+}
+function normalizeSpreadsheetTableTotalsLabel(value) {
+    if ('string' != typeof value) return;
+    const label = value.trim();
+    if (!label || Array.from(label).length > MAX_SPREADSHEET_TABLE_TOTALS_LABEL_LENGTH || /[\u0000-\u001f\u007f]/u.test(label)) return;
+    return label;
+}
+function spreadsheetTableTotalsFunctionFromOoxml(value) {
+    if ('string' != typeof value) return;
+    const normalized = value.trim().toLowerCase();
+    if ('custom' === normalized) return 'custom';
+    const entry = Object.entries(OOXML_TOTALS_FUNCTIONS).find(([, token])=>token.toLowerCase() === normalized);
+    return entry?.[0];
+}
+function spreadsheetTableTotalsFunctionToOoxml(value) {
+    if (!value || 'custom' === value) return 'custom' === value ? 'custom' : void 0;
+    return OOXML_TOTALS_FUNCTIONS[value];
+}
+function spreadsheetTableTotalsFormula(table, columnOffset) {
+    const column = table.columns[columnOffset];
+    if (!column) return;
+    const custom = normalizeSpreadsheetTableTotalsFormula(column.totalsFormula);
+    if (custom) return custom;
+    const functionName = normalizeSpreadsheetTableTotalsFunction(column.totalsFunction);
+    if (!functionName || 'custom' === functionName) return;
+    const code = SUBTOTAL_CODES[functionName];
+    if (!code) return;
+    return `=SUBTOTAL(${code},${table.name}[${escapeStructuredColumnName(column.name)}])`;
+}
+function spreadsheetTableTotalsColumnPatch(columns, patches) {
+    if (void 0 === patches) return columns.map((column)=>({
+            ...column
+        }));
+    const entries = Array.isArray(patches) ? patches.flatMap((patch, offset)=>patch ? [
+            [
+                String(offset),
+                patch
+            ]
+        ] : []) : Object.entries(patches);
+    const next = columns.map((column)=>({
+            ...column
+        }));
+    for (const [rawOffset, patch] of entries){
+        const offset = Number(rawOffset);
+        if (!Number.isSafeInteger(offset) || offset < 0 || offset >= next.length || !patch || 'object' != typeof patch || Array.isArray(patch)) return null;
+        const current = next[offset];
+        if (!current) return null;
+        const candidate = {
+            ...current
+        };
+        if (Object.hasOwn(patch, 'totalsFunction')) if (null === patch.totalsFunction || '' === patch.totalsFunction) delete candidate.totalsFunction;
+        else {
+            const functionName = normalizeSpreadsheetTableTotalsFunction(patch.totalsFunction);
+            if (!functionName) return null;
+            candidate.totalsFunction = functionName;
+        }
+        if (Object.hasOwn(patch, 'totalsLabel')) if (null === patch.totalsLabel || '' === patch.totalsLabel) delete candidate.totalsLabel;
+        else {
+            const label = normalizeSpreadsheetTableTotalsLabel(patch.totalsLabel);
+            if (!label) return null;
+            candidate.totalsLabel = label;
+        }
+        if (Object.hasOwn(patch, 'totalsFormula')) if (null === patch.totalsFormula || '' === patch.totalsFormula) delete candidate.totalsFormula;
+        else {
+            const formula = normalizeSpreadsheetTableTotalsFormula(patch.totalsFormula);
+            if (!formula) return null;
+            candidate.totalsFormula = formula;
+        }
+        if (candidate.totalsFormula) {
+            if (void 0 !== candidate.totalsFunction && 'custom' !== candidate.totalsFunction) return null;
+            candidate.totalsFunction = 'custom';
+        } else if ('custom' === candidate.totalsFunction) return null;
+        if (void 0 !== candidate.totalsFunction && 'custom' !== candidate.totalsFunction) delete candidate.totalsFormula;
+        if (void 0 !== candidate.totalsFunction && candidate.totalsLabel) delete candidate.totalsLabel;
+        next[offset] = candidate;
+    }
+    return next;
+}
+function withDefaultSpreadsheetTableTotalsLabel(columns, totalsRow) {
+    const next = columns.map((column)=>({
+            ...column
+        }));
+    if (!totalsRow || !next.length) return next;
+    const hasExplicitLabel = next.some((column)=>column.totalsLabel);
+    if (hasExplicitLabel) return next;
+    const first = next[0];
+    if (first && !first.totalsFunction && !first.totalsFormula) first.totalsLabel = DEFAULT_SPREADSHEET_TABLE_TOTALS_LABEL;
+    return next;
+}
+function spreadsheetTableTotalsRowHasContent(sheet, table, row = table.totalsRow ? table.range.row[1] : table.range.row[1] + 1) {
+    for(let column = table.range.column[0]; column <= table.range.column[1]; column += 1)if (!spreadsheetTableTotalsCellIsEmpty(spreadsheetTableTotalsCellAt(sheet, row, column))) return true;
+    return false;
+}
+function synchronizeSpreadsheetTableTotalsRow(sheet, previousTable, nextTable, options = {}) {
+    if (!nextTable.totalsRow) return sheet;
+    const force = true === options.force;
+    const previousRow = previousTable?.range.row[1];
+    const nextRow = nextTable.range.row[1];
+    const width = nextTable.range.column[1] - nextTable.range.column[0] + 1;
+    const updates = new Map();
+    for(let offset = 0; offset < width; offset += 1){
+        const column = nextTable.range.column[0] + offset;
+        const nextColumn = nextTable.columns[offset];
+        if (!nextColumn) continue;
+        const previousColumn = previousTable?.columns[offset];
+        const oldFormula = previousTable ? spreadsheetTableTotalsFormula(previousTable, offset) : void 0;
+        const newFormula = spreadsheetTableTotalsFormula(nextTable, offset);
+        const oldLabel = normalizeSpreadsheetTableTotalsLabel(previousColumn?.totalsLabel);
+        const newLabel = normalizeSpreadsheetTableTotalsLabel(nextColumn.totalsLabel);
+        const changed = force || void 0 === previousTable || previousTable.name !== nextTable.name || previousTable.range.row[1] !== nextTable.range.row[1] || previousColumn?.totalsFunction !== nextColumn.totalsFunction || previousColumn?.totalsFormula !== nextColumn.totalsFormula || previousColumn?.totalsLabel !== nextColumn.totalsLabel || previousColumn?.name !== nextColumn.name;
+        const current = spreadsheetTableTotalsCellAt(sheet, nextRow, column);
+        const previousCell = void 0 === previousRow ? null : spreadsheetTableTotalsCellAt(sheet, previousRow, column);
+        const styleSource = current ?? previousCell;
+        const empty = spreadsheetTableTotalsCellIsEmpty(current);
+        const currentFormula = normalizeSpreadsheetTableTotalsFormula(current?.f);
+        const generatedFormula = Boolean(oldFormula && currentFormula && formulasEqual(currentFormula, oldFormula));
+        const generatedLabel = Boolean(oldLabel && !current?.f && spreadsheetTableCellText(current) === oldLabel);
+        const replaceable = force || empty || changed && (generatedFormula || generatedLabel);
+        if (newFormula && replaceable) updates.set(column, spreadsheetCellWithTotalsFormula(styleSource, newFormula));
+        else if (newLabel && replaceable) updates.set(column, spreadsheetCellWithTotalsLabel(styleSource, newLabel));
+        else if (!newFormula && !newLabel && changed && (generatedFormula || generatedLabel)) updates.set(column, clearSpreadsheetTableTotalsCell(current));
+    }
+    return applySpreadsheetTableTotalsCellUpdates(sheet, nextRow, updates);
+}
+function reconcileSpreadsheetTableTotalsColumns(sheet, table, editedOffsets) {
+    return table.columns.map((column, offset)=>{
+        const candidate = {
+            ...column
+        };
+        const declaredFunction = normalizeSpreadsheetTableTotalsFunction(candidate.totalsFunction);
+        const declaredFormula = normalizeSpreadsheetTableTotalsFormula(candidate.totalsFormula);
+        if (declaredFunction) candidate.totalsFunction = declaredFunction;
+        else delete candidate.totalsFunction;
+        if (declaredFormula) candidate.totalsFormula = declaredFormula;
+        else delete candidate.totalsFormula;
+        const label = normalizeSpreadsheetTableTotalsLabel(candidate.totalsLabel);
+        if (label) candidate.totalsLabel = label;
+        else delete candidate.totalsLabel;
+        if (!table.totalsRow) return candidate;
+        const cell = spreadsheetTableTotalsCellAt(sheet, table.range.row[1], table.range.column[0] + offset);
+        if (editedOffsets && !editedOffsets.has(offset)) return candidate;
+        const cellFormula = normalizeSpreadsheetTableTotalsFormula(cell?.f);
+        const expected = spreadsheetTableTotalsFormula({
+            ...table,
+            columns: [
+                {
+                    ...candidate
+                }
+            ]
+        }, 0);
+        if (cellFormula) {
+            if (expected && formulasEqual(cellFormula, expected)) return candidate;
+            delete candidate.totalsFunction;
+            delete candidate.totalsFormula;
+            candidate.totalsFunction = 'custom';
+            candidate.totalsFormula = cellFormula;
+            return candidate;
+        }
+        delete candidate.totalsFunction;
+        delete candidate.totalsFormula;
+        const cellLabel = normalizeSpreadsheetTableTotalsLabel(spreadsheetTableCellText(cell));
+        if (cellLabel) if (candidate.totalsLabel && candidate.totalsLabel !== cellLabel) delete candidate.totalsLabel;
+        else candidate.totalsLabel = cellLabel;
+        else delete candidate.totalsLabel;
+        return candidate;
+    });
+}
+function escapeStructuredColumnName(value) {
+    return value.replaceAll(']', ']]');
+}
+function formulasEqual(left, right) {
+    return left.trim().replace(/\s+/g, '').toLocaleLowerCase() === right.trim().replace(/\s+/g, '').toLocaleLowerCase();
+}
+function spreadsheetTableTotalsCellAt(sheet, row, column) {
+    return sheet.data?.[row]?.[column] ?? sheet.celldata?.find((entry)=>entry.r === row && entry.c === column)?.v ?? null;
+}
+function spreadsheetTableTotalsCellIsEmpty(cell) {
+    return !cell?.f && (cell?.v === void 0 || null === cell.v || '' === cell.v) && (cell?.m === void 0 || null === cell.m || '' === cell.m);
+}
+function spreadsheetTableCellText(cell) {
+    const value = cell?.m ?? cell?.v;
+    return null == value ? '' : String(value);
+}
+function spreadsheetCellWithTotalsFormula(source, formula) {
+    const { f: _formula, m: _display, v: _value, ...presentation } = source ?? {};
+    return {
+        ...presentation,
+        f: formula
+    };
+}
+function spreadsheetCellWithTotalsLabel(source, label) {
+    const { f: _formula, ...withoutFormula } = source ?? {};
+    return {
+        ...withoutFormula,
+        m: label,
+        v: label
+    };
+}
+function clearSpreadsheetTableTotalsCell(source) {
+    if (!source) return null;
+    const { f: _formula, m: _display, v: _value, ...presentation } = source;
+    return Object.keys(presentation).length ? presentation : null;
+}
+function applySpreadsheetTableTotalsCellUpdates(sheet, rowIndex, updates) {
+    if (!updates.size) return sheet;
+    if (void 0 !== sheet.data) {
+        const data = sheet.data.slice();
+        const source = data[rowIndex];
+        const row = source ? source.slice() : [];
+        for (const [column, cell] of updates)row[column] = cell;
+        data[rowIndex] = row;
+        return {
+            ...sheet,
+            data
+        };
+    }
+    const entries = [
+        ...sheet.celldata ?? []
+    ];
+    const indexes = new Map(entries.map((entry, index)=>[
+            `${entry.r}:${entry.c}`,
+            index
+        ]));
+    for (const [column, cell] of updates){
+        const key = `${rowIndex}:${column}`;
+        const index = indexes.get(key);
+        if (null === cell) {
+            if (void 0 !== index) entries.splice(index, 1);
+            if (void 0 !== index) {
+                indexes.clear();
+                entries.forEach((entry, nextIndex)=>{
+                    indexes.set(`${entry.r}:${entry.c}`, nextIndex);
+                });
+            }
+            continue;
+        }
+        const entry = {
+            r: rowIndex,
+            c: column,
+            v: cell
+        };
+        if (void 0 === index) {
+            indexes.set(key, entries.length);
+            entries.push(entry);
+        } else entries[index] = entry;
+    }
+    entries.sort((left, right)=>left.r - right.r || left.c - right.c);
+    return {
+        ...sheet,
+        celldata: entries
+    };
+}
 function requiredCoordinate(value, maximum, label, sheetId) {
     if (!Number.isSafeInteger(value) || value < 0 || value >= maximum) invalidWorkOfficeSpreadsheetInput(`a valid ${label} coordinate in sheet '${sheetId}'`);
     return value;
@@ -203,7 +537,6 @@ function invalidWorkOfficeSpreadsheetInput(expected) {
 const MAX_POPULATED_CELLS = 1000000;
 const MAX_DENSE_MATRIX_CELLS = 1000000;
 const MAX_FILTER_VALUES_PER_COLUMN = 10000;
-const MAX_FILTER_VALUE_CHARACTERS = 32767;
 const MAX_FILTER_TEXT_BYTES = 1048576;
 const FILTER_TEXT_ENCODER = new TextEncoder();
 const SPREADSHEET_DYNAMIC_FILTERS = new Set([
@@ -428,20 +761,46 @@ function requiredSpreadsheetTableColumns(value, width, label) {
         const record = requiredInputRecord(candidate, `${label} column`);
         assertOptionalRecordKeys(record, [
             'name',
-            'calculatedFormula'
+            'calculatedFormula',
+            'totalsFunction',
+            'totalsLabel',
+            'totalsFormula'
         ], `column for ${label}`);
         const name = requiredTableColumnName(record.name, label);
         const normalized = name.toLocaleLowerCase();
         if (names.has(normalized)) invalidWorkOfficeSpreadsheetInput(`unique column names for ${label}`);
         names.add(normalized);
-        if (void 0 === record.calculatedFormula) return {
+        let calculatedFormula;
+        if (void 0 !== record.calculatedFormula) {
+            calculatedFormula = normalizeSpreadsheetTableCalculatedFormula(record.calculatedFormula);
+            if (!calculatedFormula || calculatedFormula !== record.calculatedFormula) invalidWorkOfficeSpreadsheetInput(`a bounded structured calculated-column formula for ${label}`);
+        }
+        const totalsFunction = void 0 === record.totalsFunction ? void 0 : normalizeSpreadsheetTableTotalsFunction(record.totalsFunction);
+        if (void 0 !== record.totalsFunction && (!totalsFunction || totalsFunction !== record.totalsFunction)) invalidWorkOfficeSpreadsheetInput(`a supported totals-row function for ${label}`);
+        const totalsLabel = void 0 === record.totalsLabel ? void 0 : normalizeSpreadsheetTableTotalsLabel(record.totalsLabel);
+        if (void 0 !== record.totalsLabel && (!totalsLabel || totalsLabel !== record.totalsLabel)) invalidWorkOfficeSpreadsheetInput(`a bounded totals-row label for ${label}`);
+        const totalsFormula = void 0 === record.totalsFormula ? void 0 : normalizeSpreadsheetTableTotalsFormula(record.totalsFormula);
+        if (void 0 !== record.totalsFormula && (!totalsFormula || totalsFormula !== record.totalsFormula)) invalidWorkOfficeSpreadsheetInput(`a bounded totals-row formula for ${label}`);
+        if (totalsFormula && 'custom' !== totalsFunction) invalidWorkOfficeSpreadsheetInput(`custom totals-row formulas to declare the custom function for ${label}`);
+        if ('custom' === totalsFunction && !totalsFormula) invalidWorkOfficeSpreadsheetInput(`custom totals-row functions to include a formula for ${label}`);
+        if ((totalsFunction || totalsFormula) && totalsLabel) invalidWorkOfficeSpreadsheetInput(`totals-row labels not to share a cell with a formula for ${label}`);
+        if (!calculatedFormula && !totalsFunction && !totalsLabel && !totalsFormula) return {
             name
         };
-        const calculatedFormula = normalizeSpreadsheetTableCalculatedFormula(record.calculatedFormula);
-        if (!calculatedFormula || calculatedFormula !== record.calculatedFormula) invalidWorkOfficeSpreadsheetInput(`a bounded structured calculated-column formula for ${label}`);
         return {
             name,
-            calculatedFormula
+            ...calculatedFormula ? {
+                calculatedFormula
+            } : {},
+            ...totalsFunction ? {
+                totalsFunction
+            } : {},
+            ...totalsLabel ? {
+                totalsLabel
+            } : {},
+            ...totalsFormula ? {
+                totalsFormula
+            } : {}
         };
     });
 }
@@ -504,19 +863,16 @@ function requiredSpreadsheetTableFilterCriteria(value, label, textBudget) {
         case 'contains':
         case 'does-not-contain':
         case 'begins-with':
+        case 'does-not-begin-with':
         case 'ends-with':
+        case 'does-not-end-with':
+        case 'matches-wildcard':
+        case 'does-not-match-wildcard':
         case 'greater-than':
         case 'greater-than-or-equal':
         case 'less-than':
         case 'less-than-or-equal':
-            assertExactRecordKeys(record, [
-                'type',
-                'value'
-            ], `filter criteria for ${label}`);
-            return {
-                type,
-                value: requiredSpreadsheetFilterText(record.value, label, textBudget)
-            };
+            return requiredSpreadsheetCustomFilterCondition(record, label, textBudget);
         case 'between':
         case 'not-between':
             assertExactRecordKeys(record, [
@@ -537,6 +893,22 @@ function requiredSpreadsheetTableFilterCriteria(value, label, textBudget) {
             return {
                 type
             };
+        case 'compound':
+            assertExactRecordKeys(record, [
+                'type',
+                'conjunction',
+                'conditions'
+            ], `filter criteria for ${label}`);
+            if ('and' !== record.conjunction && 'or' !== record.conjunction) invalidWorkOfficeSpreadsheetInput(`an 'and' or 'or' conjunction for compound filter criteria for ${label}`);
+            if (!Array.isArray(record.conditions) || 2 !== record.conditions.length) invalidWorkOfficeSpreadsheetInput(`exactly two custom filter conditions for ${label}`);
+            return {
+                type,
+                conjunction: record.conjunction,
+                conditions: [
+                    requiredSpreadsheetCustomFilterCondition(record.conditions[0], label, textBudget),
+                    requiredSpreadsheetCustomFilterCondition(record.conditions[1], label, textBudget)
+                ]
+            };
         case 'top':
         case 'bottom':
             assertExactRecordKeys(record, [
@@ -571,15 +943,44 @@ function requiredSpreadsheetTableFilterCriteria(value, label, textBudget) {
             invalidWorkOfficeSpreadsheetInput(`supported filter criteria for ${label}`);
     }
 }
+function requiredSpreadsheetCustomFilterCondition(value, label, textBudget) {
+    const record = validateJsonRecord(requiredInputRecord(value, `custom filter condition for ${label}`), `custom filter condition for ${label}`);
+    switch(record.type){
+        case 'equals':
+        case 'not-equals':
+        case 'contains':
+        case 'does-not-contain':
+        case 'begins-with':
+        case 'does-not-begin-with':
+        case 'ends-with':
+        case 'does-not-end-with':
+        case 'matches-wildcard':
+        case 'does-not-match-wildcard':
+        case 'greater-than':
+        case 'greater-than-or-equal':
+        case 'less-than':
+        case 'less-than-or-equal':
+            assertExactRecordKeys(record, [
+                'type',
+                'value'
+            ], `custom filter condition for ${label}`);
+            return {
+                type: record.type,
+                value: requiredSpreadsheetFilterText(record.value, label, textBudget)
+            };
+        default:
+            invalidWorkOfficeSpreadsheetInput(`supported custom filter condition for ${label}`);
+    }
+}
 function requiredSpreadsheetFilterText(value, label, textBudget) {
-    if ('string' != typeof value) invalidWorkOfficeSpreadsheetInput(`filter text containing 1 to ${MAX_FILTER_VALUE_CHARACTERS.toLocaleString()} characters for ${label}`);
+    if ('string' != typeof value) invalidWorkOfficeSpreadsheetInput(`filter text containing 1 to ${32767..toLocaleString()} characters for ${label}`);
     let characters = 0;
     for (const character of value){
         characters += 1;
         const codePoint = character.codePointAt(0);
         if (void 0 === codePoint || !(0x9 === codePoint || 0xa === codePoint || 0xd === codePoint || codePoint >= 0x20 && codePoint <= 0xd7ff || codePoint >= 0xe000 && codePoint <= 0xfffd || codePoint >= 0x10000 && codePoint <= 0x10ffff)) invalidWorkOfficeSpreadsheetInput(`XML-compatible filter text for ${label}`);
     }
-    if (characters < 1 || characters > MAX_FILTER_VALUE_CHARACTERS) invalidWorkOfficeSpreadsheetInput(`filter text containing 1 to ${MAX_FILTER_VALUE_CHARACTERS.toLocaleString()} characters for ${label}`);
+    if (characters < 1 || characters > 32767) invalidWorkOfficeSpreadsheetInput(`filter text containing 1 to ${32767..toLocaleString()} characters for ${label}`);
     textBudget.bytes += FILTER_TEXT_ENCODER.encode(value).byteLength;
     if (textBudget.bytes > MAX_FILTER_TEXT_BYTES) invalidWorkOfficeSpreadsheetInput(`filter text totaling at most ${MAX_FILTER_TEXT_BYTES.toLocaleString()} bytes for ${label}`);
     return value;
@@ -1800,7 +2201,867 @@ function assertInitializedSpreadsheetSession(session) {
     if (metadata?.initialized) return;
     throw new WorkOfficeCollaborationError('office.collaboration.not_initialized', 'The Spreadsheet collaboration session has not been initialized.');
 }
+const WORK_SPREADSHEET_FILTER_TEXT_MAX_CHARACTERS = 32767;
+function workSpreadsheetFilterTextCharacters(value) {
+    let characters = 0;
+    for (const _character of value)characters += 1;
+    return characters;
+}
+function workSpreadsheetFilterTextIsBounded(value) {
+    const characters = workSpreadsheetFilterTextCharacters(value);
+    return characters >= 1 && characters <= WORK_SPREADSHEET_FILTER_TEXT_MAX_CHARACTERS;
+}
 const MILLISECONDS_PER_DAY = 86400000;
+const EXCEL_1900_EPOCH_UTC = Date.UTC(1899, 11, 30);
+const EXCEL_1900_CIVIL_EPOCH_UTC = Date.UTC(1899, 11, 31);
+const EXCEL_1900_LOCAL_BASE = new Date(1899, 11, 30);
+const SERIAL_INTEGER_EPSILON = 1e-7;
+const CALENDAR_MONTH_FILTERS = [
+    'month-1',
+    'month-2',
+    'month-3',
+    'month-4',
+    'month-5',
+    'month-6',
+    'month-7',
+    'month-8',
+    'month-9',
+    'month-10',
+    'month-11',
+    'month-12'
+];
+const CALENDAR_QUARTER_FILTERS = [
+    'quarter-1',
+    'quarter-2',
+    'quarter-3',
+    'quarter-4'
+];
+function workSpreadsheetDynamicFilterMatcher(kind, cells, context) {
+    if ('above-average' === kind || 'below-average' === kind) return averageMatcher(kind, cells);
+    const month = CALENDAR_MONTH_FILTERS.indexOf(kind);
+    if (month >= 0) return (cell)=>spreadsheetDateParts(cell)?.month === month;
+    const quarter = CALENDAR_QUARTER_FILTERS.indexOf(kind);
+    if (quarter >= 0) return (cell)=>spreadsheetDateParts(cell)?.quarter === quarter;
+    const bounds = relativeDateBounds(kind, context.now);
+    if (!bounds) return null;
+    return (cell)=>{
+        const day = spreadsheetDateSerialDay(cell);
+        return null !== day && day >= bounds.start && day < bounds.end;
+    };
+}
+function workSpreadsheetCellIsDate(cell) {
+    return null !== spreadsheetDateSerialDay(cell);
+}
+function averageMatcher(kind, cells) {
+    const average = finiteArithmeticMean(cells);
+    if (null === average) return ()=>false;
+    return 'above-average' === kind ? (cell)=>{
+        const value = spreadsheetNumericCellValue(cell);
+        return null !== value && value > average;
+    } : (cell)=>{
+        const value = spreadsheetNumericCellValue(cell);
+        return null !== value && value < average;
+    };
+}
+function finiteArithmeticMean(cells) {
+    let count = 0;
+    let scale = 0;
+    let scaledTotal = 0;
+    for (const cell of cells){
+        const value = spreadsheetNumericCellValue(cell);
+        if (null === value) continue;
+        count += 1;
+        const magnitude = Math.abs(value);
+        if (magnitude > scale) {
+            scaledTotal = scale / magnitude * scaledTotal + value / magnitude;
+            scale = magnitude;
+        } else if (scale > 0) scaledTotal += value / scale;
+    }
+    return count ? scaledTotal / count * scale : null;
+}
+function relativeDateBounds(kind, now) {
+    const timestamp = now.getTime();
+    const year = now.getFullYear();
+    if (!Number.isFinite(timestamp) || !Number.isSafeInteger(year) || year < 1900 || year > 9999) return null;
+    const month = now.getMonth();
+    const today = excelSerialFromCivilDate(year, month, now.getDate());
+    if ('yesterday' === kind) return dayBounds(today - 1);
+    if ('today' === kind) return dayBounds(today);
+    if ('tomorrow' === kind) return dayBounds(today + 1);
+    const weekStart = today - now.getDay();
+    if ('last-week' === kind) return rangeBounds(weekStart - 7, weekStart);
+    if ('this-week' === kind) return rangeBounds(weekStart, weekStart + 7);
+    if ('next-week' === kind) return rangeBounds(weekStart + 7, weekStart + 14);
+    const monthStart = excelSerialFromCivilDate(year, month, 1);
+    if ('last-month' === kind) return rangeBounds(excelSerialFromCivilDate(year, month - 1, 1), monthStart);
+    if ('this-month' === kind) return rangeBounds(monthStart, excelSerialFromCivilDate(year, month + 1, 1));
+    if ('next-month' === kind) return rangeBounds(excelSerialFromCivilDate(year, month + 1, 1), excelSerialFromCivilDate(year, month + 2, 1));
+    const quarterStartMonth = 3 * Math.floor(month / 3);
+    const quarterStart = excelSerialFromCivilDate(year, quarterStartMonth, 1);
+    if ('last-quarter' === kind) return rangeBounds(excelSerialFromCivilDate(year, quarterStartMonth - 3, 1), quarterStart);
+    if ('this-quarter' === kind) return rangeBounds(quarterStart, excelSerialFromCivilDate(year, quarterStartMonth + 3, 1));
+    if ('next-quarter' === kind) return rangeBounds(excelSerialFromCivilDate(year, quarterStartMonth + 3, 1), excelSerialFromCivilDate(year, quarterStartMonth + 6, 1));
+    const yearStart = excelSerialFromCivilDate(year, 0, 1);
+    if ('last-year' === kind) return rangeBounds(excelSerialFromCivilDate(year - 1, 0, 1), yearStart);
+    if ('this-year' === kind) return rangeBounds(yearStart, excelSerialFromCivilDate(year + 1, 0, 1));
+    if ('next-year' === kind) return rangeBounds(excelSerialFromCivilDate(year + 1, 0, 1), excelSerialFromCivilDate(year + 2, 0, 1));
+    if ('year-to-date' === kind) return rangeBounds(yearStart, today + 1);
+    return null;
+}
+function spreadsheetDateParts(cell) {
+    const day = spreadsheetDateSerialDay(cell);
+    if (null === day) return null;
+    const adjustedDay = day > 60 ? day - 1 : day;
+    const date = new Date(EXCEL_1900_CIVIL_EPOCH_UTC + adjustedDay * MILLISECONDS_PER_DAY);
+    const timestamp = date.getTime();
+    const year = date.getUTCFullYear();
+    if (!Number.isFinite(timestamp) || year < 1900 || year > 9999) return null;
+    const month = date.getUTCMonth();
+    return {
+        month,
+        quarter: Math.floor(month / 3)
+    };
+}
+function spreadsheetDateSerialDay(cell) {
+    const serial = spreadsheetDateCellSerial(cell);
+    if (null === serial) return null;
+    const rounded = Math.round(serial);
+    const normalized = Math.abs(serial - rounded) <= SERIAL_INTEGER_EPSILON ? rounded : serial;
+    const day = Math.floor(normalized);
+    return day >= 1 && 60 !== day ? day : null;
+}
+function spreadsheetDateCellSerial(cell) {
+    const value = spreadsheetCellRawValue(cell);
+    if (value instanceof Date) {
+        if (!Number.isFinite(value.getTime())) return null;
+        const threshold = EXCEL_1900_LOCAL_BASE.getTime() + (value.getTimezoneOffset() - EXCEL_1900_LOCAL_BASE.getTimezoneOffset()) * 60000;
+        const serial = (value.getTime() - threshold) / MILLISECONDS_PER_DAY;
+        return Number.isFinite(serial) ? serial : null;
+    }
+    return 'number' == typeof value && Number.isFinite(value) && cell?.ct?.t === 'd' ? value : null;
+}
+function spreadsheetNumericCellValue(cell) {
+    if (null !== spreadsheetDateCellSerial(cell)) return null;
+    const value = spreadsheetCellRawValue(cell);
+    return 'number' == typeof value && Number.isFinite(value) ? value : null;
+}
+function spreadsheetCellRawValue(cell) {
+    const candidate = cell;
+    return candidate?.v ?? candidate?.m;
+}
+function excelSerialFromCivilDate(year, month, day) {
+    return (Date.UTC(year, month, day) - EXCEL_1900_EPOCH_UTC) / MILLISECONDS_PER_DAY;
+}
+function dayBounds(day) {
+    return {
+        start: day,
+        end: day + 1
+    };
+}
+function rangeBounds(start, end) {
+    return {
+        start,
+        end
+    };
+}
+const WILDCARD_ESCAPES = new Set([
+    '*',
+    '?',
+    '~'
+]);
+const BITSET_MINIMUM_SEARCH_WORK = 1000000;
+const BITSET_MINIMUM_TOKENS = 256;
+const BITSET_MAXIMUM_LITERAL_VALUES = 256;
+function workSpreadsheetWildcardMatcher(source) {
+    const tokens = wildcardTokens(source);
+    const literalMatcher = literalWildcardMatcher(tokens);
+    if (literalMatcher) return (value)=>literalMatcher(comparableWildcardText(value));
+    const fixedWidthMatcher = fixedWidthWildcardMatcher(tokens);
+    return (value)=>fixedWidthMatcher(comparableWildcardText(value));
+}
+function workSpreadsheetHasUnescapedWildcard(source) {
+    const characters = [
+        ...source
+    ];
+    for(let index = 0; index < characters.length; index += 1){
+        const character = characters[index];
+        if ('~' === character && WILDCARD_ESCAPES.has(characters[index + 1] ?? '')) {
+            index += 1;
+            continue;
+        }
+        if ('*' === character || '?' === character) return true;
+    }
+    return false;
+}
+function wildcardTokens(source) {
+    const characters = [
+        ...source
+    ];
+    const tokens = [];
+    let literal = '';
+    const flushLiteral = ()=>{
+        if (!literal) return;
+        for (const value of comparableWildcardText(literal))tokens.push({
+            kind: 'literal',
+            value
+        });
+        literal = '';
+    };
+    for(let index = 0; index < characters.length; index += 1){
+        const character = characters[index] ?? '';
+        const escaped = characters[index + 1] ?? '';
+        if ('~' === character && WILDCARD_ESCAPES.has(escaped)) {
+            literal += escaped;
+            index += 1;
+            continue;
+        }
+        if ('*' === character) {
+            flushLiteral();
+            if (tokens.at(-1)?.kind !== 'many') tokens.push({
+                kind: 'many'
+            });
+            continue;
+        }
+        if ('?' === character) {
+            flushLiteral();
+            tokens.push({
+                kind: 'single'
+            });
+            continue;
+        }
+        literal += character;
+    }
+    flushLiteral();
+    return tokens;
+}
+function literalWildcardMatcher(tokens) {
+    if (tokens.some((token)=>'single' === token.kind)) return null;
+    const startsWithMany = tokens[0]?.kind === 'many';
+    const endsWithMany = tokens.at(-1)?.kind === 'many';
+    const segments = [];
+    let segment = '';
+    for (const token of tokens){
+        if ('many' === token.kind) {
+            if (segment) segments.push(segment);
+            segment = '';
+            continue;
+        }
+        if ('literal' !== token.kind) return null;
+        segment += token.value;
+    }
+    if (segment) segments.push(segment);
+    if (!segments.length) return tokens.length ? ()=>true : (value)=>'' === value;
+    if (!startsWithMany && !endsWithMany && 1 === segments.length) return (value)=>value === segments[0];
+    return (value)=>{
+        let minimumIndex = 0;
+        let segmentIndex = 0;
+        if (!startsWithMany) {
+            const first = segments[0] ?? '';
+            if (!value.startsWith(first)) return false;
+            minimumIndex = first.length;
+            segmentIndex = 1;
+        }
+        const searchableSegments = endsWithMany ? segments.length : segments.length - 1;
+        for(; segmentIndex < searchableSegments; segmentIndex += 1){
+            const current = segments[segmentIndex] ?? '';
+            const found = value.indexOf(current, minimumIndex);
+            if (found < 0) return false;
+            minimumIndex = found + current.length;
+        }
+        if (endsWithMany) return true;
+        const last = segments.at(-1) ?? '';
+        return value.endsWith(last) && value.length - last.length >= minimumIndex;
+    };
+}
+function fixedWidthWildcardMatcher(tokens) {
+    const startsWithMany = tokens[0]?.kind === 'many';
+    const endsWithMany = tokens.at(-1)?.kind === 'many';
+    const segments = [];
+    let current = [];
+    for (const token of tokens){
+        if ('many' === token.kind) {
+            if (current.length) segments.push(fixedWidthWildcardSegment(current));
+            current = [];
+            continue;
+        }
+        current.push(token);
+    }
+    if (current.length) segments.push(fixedWidthWildcardSegment(current));
+    if (!segments.length) return ()=>true;
+    if (!startsWithMany && !endsWithMany && 1 === segments.length) {
+        const only = segments[0];
+        return (value)=>{
+            const characters = [
+                ...value
+            ];
+            return characters.length === only.tokens.length && fixedWidthWildcardSegmentMatches(only, characters, 0);
+        };
+    }
+    return (value)=>{
+        const characters = [
+            ...value
+        ];
+        let minimumIndex = 0;
+        let segmentIndex = 0;
+        let maximumEnd = characters.length;
+        let finalSegment = segments.length;
+        if (!startsWithMany) {
+            const first = segments[0];
+            if (!fixedWidthWildcardSegmentMatches(first, characters, 0)) return false;
+            minimumIndex = first.tokens.length;
+            segmentIndex = 1;
+        }
+        if (!endsWithMany) {
+            finalSegment -= 1;
+            const last = segments[finalSegment];
+            const start = characters.length - last.tokens.length;
+            if (start < minimumIndex || !fixedWidthWildcardSegmentMatches(last, characters, start)) return false;
+            maximumEnd = start;
+        }
+        if (segmentIndex >= finalSegment) return true;
+        const offsets = wildcardCodePointOffsets(characters);
+        for(; segmentIndex < finalSegment; segmentIndex += 1){
+            const segment = segments[segmentIndex];
+            const found = findFixedWidthWildcardSegment(segment, value, characters, offsets, minimumIndex, maximumEnd);
+            if (found < 0) return false;
+            minimumIndex = found + segment.tokens.length;
+        }
+        return true;
+    };
+}
+function fixedWidthWildcardSegment(tokens) {
+    let anchor = null;
+    let literalStart = -1;
+    const considerLiteralRun = (end)=>{
+        if (literalStart < 0) return;
+        const text = tokens.slice(literalStart, end).map((token)=>'literal' === token.kind ? token.value : '').join('');
+        if (!anchor || end - literalStart >= [
+            ...anchor.text
+        ].length) anchor = {
+            offset: literalStart,
+            text
+        };
+        literalStart = -1;
+    };
+    for(let index = 0; index <= tokens.length; index += 1)if (tokens[index]?.kind === 'literal') {
+        if (literalStart < 0) literalStart = index;
+    } else considerLiteralRun(index);
+    return {
+        anchor,
+        bitset: fixedWidthWildcardBitset(tokens),
+        tokens
+    };
+}
+function findFixedWidthWildcardSegment(segment, value, characters, offsets, minimumIndex, maximumEnd) {
+    if (minimumIndex + segment.tokens.length > maximumEnd) return -1;
+    if (!segment.anchor) return minimumIndex;
+    if (segment.bitset && segment.tokens.length * (maximumEnd - minimumIndex) >= BITSET_MINIMUM_SEARCH_WORK) return findFixedWidthWildcardSegmentWithBitset(segment, characters, minimumIndex, maximumEnd);
+    const minimumAnchorIndex = minimumIndex + segment.anchor.offset;
+    let anchorOffset = value.indexOf(segment.anchor.text, offsets[minimumAnchorIndex] ?? value.length);
+    while(anchorOffset >= 0){
+        const anchorIndex = codePointIndexAtOffset(offsets, anchorOffset);
+        if (anchorIndex >= 0) {
+            const start = anchorIndex - segment.anchor.offset;
+            if (start + segment.tokens.length > maximumEnd) return -1;
+            if (start >= minimumIndex && fixedWidthWildcardSegmentMatches(segment, characters, start)) return start;
+        }
+        anchorOffset = value.indexOf(segment.anchor.text, anchorOffset + 1);
+    }
+    return -1;
+}
+function fixedWidthWildcardBitset(tokens) {
+    if (tokens.length < BITSET_MINIMUM_TOKENS) return null;
+    const literalValues = new Set(tokens.flatMap((token)=>'literal' === token.kind ? [
+            token.value
+        ] : []));
+    if (literalValues.size > BITSET_MAXIMUM_LITERAL_VALUES) return null;
+    const literalMasks = new Map();
+    let singleMask = 0n;
+    for(let index = 0; index < tokens.length; index += 1){
+        const token = tokens[index];
+        const bit = 1n << BigInt(index);
+        if ('single' === token.kind) {
+            singleMask |= bit;
+            continue;
+        }
+        literalMasks.set(token.value, (literalMasks.get(token.value) ?? 0n) | bit);
+    }
+    return {
+        literalMasks,
+        matchBit: 1n << BigInt(tokens.length - 1),
+        singleMask
+    };
+}
+function findFixedWidthWildcardSegmentWithBitset(segment, characters, minimumIndex, maximumEnd) {
+    const bitset = segment.bitset;
+    if (!bitset) return -1;
+    let state = 0n;
+    for(let index = minimumIndex; index < maximumEnd; index += 1){
+        const mask = bitset.singleMask | (bitset.literalMasks.get(characters[index]) ?? 0n);
+        state = (state << 1n | 1n) & mask;
+        if ((state & bitset.matchBit) !== 0n) return index - segment.tokens.length + 1;
+    }
+    return -1;
+}
+function fixedWidthWildcardSegmentMatches(segment, characters, start) {
+    if (start < 0 || start + segment.tokens.length > characters.length) return false;
+    return segment.tokens.every((token, index)=>'single' === token.kind || token.value === characters[start + index]);
+}
+function wildcardCodePointOffsets(characters) {
+    const offsets = [
+        0
+    ];
+    for (const character of characters)offsets.push((offsets.at(-1) ?? 0) + character.length);
+    return offsets;
+}
+function codePointIndexAtOffset(offsets, target) {
+    let low = 0;
+    let high = offsets.length - 1;
+    while(low <= high){
+        const middle = Math.floor((low + high) / 2);
+        const value = offsets[middle] ?? -1;
+        if (value === target) return middle;
+        if (value < target) low = middle + 1;
+        else high = middle - 1;
+    }
+    return -1;
+}
+function comparableWildcardText(value) {
+    return value.normalize('NFKC').toLocaleLowerCase('zh-CN');
+}
+const AUTO_FILTER_CRITERIA_KIND = 'a3s-office-auto-filter-criteria';
+const AUTO_FILTER_CRITERIA_VERSION = 1;
+const SINGLE_VALUE_FILTER_TYPES = new Set([
+    'equals',
+    'not-equals',
+    'contains',
+    'does-not-contain',
+    'begins-with',
+    'does-not-begin-with',
+    'ends-with',
+    'does-not-end-with',
+    'matches-wildcard',
+    'does-not-match-wildcard',
+    'greater-than',
+    'greater-than-or-equal',
+    'less-than',
+    'less-than-or-equal'
+]);
+const DYNAMIC_FILTER_KINDS = new Set([
+    'above-average',
+    'below-average',
+    'tomorrow',
+    'today',
+    'yesterday',
+    'next-week',
+    'this-week',
+    'last-week',
+    'next-month',
+    'this-month',
+    'last-month',
+    'next-quarter',
+    'this-quarter',
+    'last-quarter',
+    'next-year',
+    'this-year',
+    'last-year',
+    'year-to-date',
+    'quarter-1',
+    'quarter-2',
+    'quarter-3',
+    'quarter-4',
+    'month-1',
+    'month-2',
+    'month-3',
+    'month-4',
+    'month-5',
+    'month-6',
+    'month-7',
+    'month-8',
+    'month-9',
+    'month-10',
+    'month-11',
+    'month-12'
+]);
+function normalizedWorkSpreadsheetAutoFilterRange(selection) {
+    const rowStart = finiteIndex(selection?.row?.[0]);
+    const rowEnd = finiteIndex(selection?.row?.[1]);
+    const columnStart = finiteIndex(selection?.column?.[0]);
+    const columnEnd = finiteIndex(selection?.column?.[1]);
+    if (null === rowStart || null === rowEnd || null === columnStart || null === columnEnd) return null;
+    return {
+        row: [
+            Math.min(rowStart, rowEnd),
+            Math.max(rowStart, rowEnd)
+        ],
+        column: [
+            Math.min(columnStart, columnEnd),
+            Math.max(columnStart, columnEnd)
+        ]
+    };
+}
+function workSpreadsheetAutoFilterCriteria(sheet, column) {
+    const range = normalizedWorkSpreadsheetAutoFilterRange(sheet?.filter_select);
+    if (!sheet || !range || !columnInRange(range, column)) return null;
+    return criteriaFromEntry(sheet.filter?.[String(column - range.column[0])]);
+}
+function workSpreadsheetAutoFilterCriteriaEntries(sheet) {
+    const range = normalizedWorkSpreadsheetAutoFilterRange(sheet.filter_select);
+    if (!range) return [];
+    const entries = [];
+    for (const [key, value] of Object.entries(sheet.filter ?? {})){
+        const column = Number(key);
+        const criteria = criteriaFromEntry(value);
+        if (criteria && Number.isSafeInteger(column) && !(column < 0) && !(column > range.column[1] - range.column[0])) entries.push({
+            column,
+            criteria
+        });
+    }
+    return entries.sort((left, right)=>left.column - right.column);
+}
+function workSpreadsheetSheetWithAutoFilterCriteria(sheet, column, criteria, context = {
+    now: new Date()
+}) {
+    const normalizedCriteria = normalizeWorkSpreadsheetFilterCriteria(criteria);
+    const range = normalizedWorkSpreadsheetAutoFilterRange(sheet.filter_select);
+    if (!normalizedCriteria || !range || !columnInRange(range, column)) return null;
+    const rowhidden = hiddenRowsForCriteria(sheet, range, column, normalizedCriteria, context);
+    if (!rowhidden) return null;
+    const manuallyHiddenRows = workSpreadsheetAutoFilterManuallyHiddenRows(sheet);
+    const filter = {
+        ...sheet.filter ?? {},
+        [String(column - range.column[0])]: filterColumnState(range, column, normalizedCriteria, rowhidden)
+    };
+    return sheetWithFilterState(sheet, filter, manuallyHiddenRows);
+}
+function workSpreadsheetSheetWithoutAutoFilterCriteria(sheet, column) {
+    const range = normalizedWorkSpreadsheetAutoFilterRange(sheet.filter_select);
+    if (!range || !columnInRange(range, column)) return null;
+    const key = String(column - range.column[0]);
+    if (!Object.hasOwn(sheet.filter ?? {}, key)) return null;
+    const filter = {
+        ...sheet.filter ?? {}
+    };
+    delete filter[key];
+    return sheetWithFilterState(sheet, filter, workSpreadsheetAutoFilterManuallyHiddenRows(sheet));
+}
+function workSpreadsheetAutoFilterManuallyHiddenRows(sheet) {
+    const owned = filterHiddenRows(sheet.filter);
+    const manuallyHidden = new Set(Object.keys(sheet.config?.rowhidden ?? {}).filter((row)=>!owned.has(row)));
+    for (const entry of Object.values(sheet.filter ?? {})){
+        const overlap = criteriaPayloadFromEntry(entry)?.manualHiddenOverlap;
+        if (Array.isArray(overlap)) {
+            for (const row of overlap)if (validHiddenRowKey(row)) manuallyHidden.add(row);
+        }
+    }
+    return manuallyHidden;
+}
+function workSpreadsheetSheetWithImportedAutoFilterCriteria(sheet, entries, context = {
+    now: new Date()
+}) {
+    const range = normalizedWorkSpreadsheetAutoFilterRange(sheet.filter_select);
+    if (!range || !entries.length) return sheet;
+    const width = range.column[1] - range.column[0] + 1;
+    const filter = {};
+    const owned = new Set();
+    for (const entry of entries){
+        const criteria = normalizeWorkSpreadsheetFilterCriteria(entry.criteria);
+        if (!criteria || !Number.isSafeInteger(entry.column) || entry.column < 0 || entry.column >= width) continue;
+        const column = range.column[0] + entry.column;
+        const rowhidden = hiddenRowsForCriteria(sheet, range, column, criteria, context) ?? {};
+        for (const row of Object.keys(rowhidden))owned.add(row);
+        filter[String(entry.column)] = filterColumnState(range, column, criteria, rowhidden);
+    }
+    if (!Object.keys(filter).length) return sheet;
+    const manuallyHiddenRows = new Set(Object.keys(sheet.config?.rowhidden ?? {}).filter((row)=>!owned.has(row)));
+    return sheetWithFilterState(sheet, filter, manuallyHiddenRows);
+}
+function normalizeWorkSpreadsheetFilterCriteria(criteria) {
+    if (!criteria || 'object' != typeof criteria || Array.isArray(criteria)) return null;
+    const value = criteria;
+    const type = value.type;
+    if ('blanks' === type || 'non-blanks' === type) return {
+        type
+    };
+    if ('values' === type) {
+        if (!Array.isArray(value.values) || 'boolean' != typeof value.includeBlanks) return null;
+        const values = value.values.filter((item)=>'string' == typeof item);
+        if (values.length !== value.values.length || !values.length && !value.includeBlanks) return null;
+        return {
+            type,
+            values: [
+                ...new Set(values)
+            ],
+            includeBlanks: value.includeBlanks
+        };
+    }
+    if ('between' === type || 'not-between' === type) return 'string' == typeof value.lower && 'string' == typeof value.upper ? {
+        type,
+        lower: value.lower,
+        upper: value.upper
+    } : null;
+    if ('compound' === type) {
+        if ('and' !== value.conjunction && 'or' !== value.conjunction || !Array.isArray(value.conditions) || 2 !== value.conditions.length) return null;
+        const first = normalizeWorkSpreadsheetCustomFilterCondition(value.conditions[0]);
+        const second = normalizeWorkSpreadsheetCustomFilterCondition(value.conditions[1]);
+        return first && second ? {
+            type,
+            conjunction: value.conjunction,
+            conditions: [
+                first,
+                second
+            ]
+        } : null;
+    }
+    if ('top' === type || 'bottom' === type) return Number.isSafeInteger(value.count) && Number(value.count) >= 1 && Number(value.count) <= 500 ? {
+        type,
+        count: Number(value.count)
+    } : null;
+    if ('top-percent' === type || 'bottom-percent' === type) return Number.isSafeInteger(value.percent) && Number(value.percent) >= 1 && Number(value.percent) <= 100 ? {
+        type,
+        percent: Number(value.percent)
+    } : null;
+    if ('dynamic' === type) return 'string' == typeof value.kind && DYNAMIC_FILTER_KINDS.has(value.kind) ? {
+        type,
+        kind: value.kind
+    } : null;
+    return normalizeWorkSpreadsheetCustomFilterCondition(value);
+}
+function normalizeWorkSpreadsheetCustomFilterCondition(condition) {
+    if (!condition || 'object' != typeof condition || Array.isArray(condition)) return null;
+    const value = condition;
+    if ('string' != typeof value.type || !SINGLE_VALUE_FILTER_TYPES.has(value.type) || 'string' != typeof value.value) return null;
+    if (('matches-wildcard' === value.type || 'does-not-match-wildcard' === value.type) && !workSpreadsheetFilterTextIsBounded(value.value)) return null;
+    return {
+        type: value.type,
+        value: value.value
+    };
+}
+function sheetWithFilterState(sheet, filter, manuallyHiddenRows) {
+    const owned = filterHiddenRows(filter);
+    const overlap = [
+        ...manuallyHiddenRows
+    ].filter((row)=>owned.has(row)).sort(compareHiddenRowKeys);
+    const rowhidden = {};
+    for (const row of manuallyHiddenRows)rowhidden[row] = 0;
+    for (const row of owned)rowhidden[row] = 0;
+    return {
+        ...sheet,
+        filter: filterWithManualHiddenOverlap(filter, overlap),
+        config: {
+            ...sheet.config ?? {},
+            rowhidden
+        }
+    };
+}
+function filterWithManualHiddenOverlap(filter, manualHiddenOverlap) {
+    return Object.fromEntries(Object.entries(filter).map(([column, entry])=>{
+        const payload = criteriaPayloadFromEntry(entry);
+        if (!payload || !entry || 'object' != typeof entry) return [
+            column,
+            entry
+        ];
+        return [
+            column,
+            {
+                ...entry,
+                caljs: {
+                    ...payload,
+                    manualHiddenOverlap: [
+                        ...manualHiddenOverlap
+                    ]
+                }
+            }
+        ];
+    }));
+}
+function filterColumnState(range, column, criteria, rowhidden) {
+    return {
+        caljs: {
+            criteria,
+            kind: AUTO_FILTER_CRITERIA_KIND,
+            version: AUTO_FILTER_CRITERIA_VERSION
+        },
+        cindex: column,
+        edc: range.column[1],
+        edr: range.row[1],
+        optionstate: true,
+        rowhidden,
+        stc: range.column[0],
+        str: range.row[0]
+    };
+}
+function hiddenRowsForCriteria(sheet, range, column, criteria, context) {
+    if ('top' === criteria.type || 'top-percent' === criteria.type || 'bottom' === criteria.type || 'bottom-percent' === criteria.type) return hiddenRowsForRankCriteria(sheet, range, column, criteria);
+    if ('dynamic' === criteria.type) return hiddenRowsForDynamicCriteria(sheet, range, column, criteria.kind, context);
+    const matches = filterMatcher(criteria);
+    if (!matches) return null;
+    const cellAt = sheetCellReader(sheet);
+    const hidden = {};
+    for(let row = range.row[0] + 1; row <= range.row[1]; row += 1)if (!matches(cellAt(row, column))) hidden[String(row)] = 0;
+    return hidden;
+}
+function hiddenRowsForDynamicCriteria(sheet, range, column, kind, context) {
+    const cellAt = sheetCellReader(sheet);
+    const cells = {
+        *[Symbol.iterator] () {
+            for(let row = range.row[0] + 1; row <= range.row[1]; row += 1)yield cellAt(row, column);
+        }
+    };
+    const matches = workSpreadsheetDynamicFilterMatcher(kind, cells, context);
+    if (!matches) return null;
+    const hidden = {};
+    for(let row = range.row[0] + 1; row <= range.row[1]; row += 1)if (!matches(cellAt(row, column))) hidden[String(row)] = 0;
+    return hidden;
+}
+function hiddenRowsForRankCriteria(sheet, range, column, criteria) {
+    const cellAt = sheetCellReader(sheet);
+    const values = [];
+    for(let row = range.row[0] + 1; row <= range.row[1]; row += 1){
+        const value = numericCellValue(cellAt(row, column));
+        if (null !== value) values.push(value);
+    }
+    const top = 'top' === criteria.type || 'top-percent' === criteria.type;
+    values.sort((left, right)=>top ? right - left : left - right);
+    const requested = 'top' === criteria.type || 'bottom' === criteria.type ? criteria.count : Math.ceil(values.length * criteria.percent / 100);
+    const boundary = values[Math.min(requested, values.length) - 1];
+    const hidden = {};
+    for(let row = range.row[0] + 1; row <= range.row[1]; row += 1){
+        const value = numericCellValue(cellAt(row, column));
+        if (null === value || void 0 === boundary || (top ? value < boundary : value > boundary)) hidden[String(row)] = 0;
+    }
+    return hidden;
+}
+function filterMatcher(criteria) {
+    if ('blanks' === criteria.type) return cellIsBlank;
+    if ('non-blanks' === criteria.type) return (cell)=>!cellIsBlank(cell);
+    if ('values' === criteria.type) {
+        const values = new Set(criteria.values.map(comparableText));
+        return (cell)=>{
+            const value = cellValue(cell);
+            if (null === value) return criteria.includeBlanks;
+            return values.has(comparableText(String(value)));
+        };
+    }
+    if ('between' === criteria.type || 'not-between' === criteria.type) return (cell)=>{
+        const lower = compareCell(cell, criteria.lower);
+        const upper = compareCell(cell, criteria.upper);
+        const between = null !== lower && null !== upper && lower >= 0 && upper <= 0;
+        return 'between' === criteria.type ? between : !between;
+    };
+    if ('compound' === criteria.type) {
+        const first = customFilterMatcher(criteria.conditions[0]);
+        const second = customFilterMatcher(criteria.conditions[1]);
+        return 'and' === criteria.conjunction ? (cell)=>first(cell) && second(cell) : (cell)=>first(cell) || second(cell);
+    }
+    if ('top' === criteria.type || 'top-percent' === criteria.type || 'bottom' === criteria.type || 'bottom-percent' === criteria.type || 'dynamic' === criteria.type) return null;
+    return customFilterMatcher(criteria);
+}
+function customFilterMatcher(criteria) {
+    if ('matches-wildcard' === criteria.type || 'does-not-match-wildcard' === criteria.type) {
+        const matchesWildcard = workSpreadsheetWildcardMatcher(criteria.value);
+        const matches = (cell)=>{
+            const value = cellValue(cell);
+            return null !== value && matchesWildcard(String(value));
+        };
+        return 'matches-wildcard' === criteria.type ? matches : (cell)=>!matches(cell);
+    }
+    const expected = criteria.value;
+    if ('contains' === criteria.type) return (cell)=>cellText(cell).includes(comparableText(expected));
+    if ('does-not-contain' === criteria.type) return (cell)=>!cellText(cell).includes(comparableText(expected));
+    if ('begins-with' === criteria.type) return (cell)=>cellText(cell).startsWith(comparableText(expected));
+    if ('does-not-begin-with' === criteria.type) return (cell)=>!cellText(cell).startsWith(comparableText(expected));
+    if ('ends-with' === criteria.type) return (cell)=>cellText(cell).endsWith(comparableText(expected));
+    if ('does-not-end-with' === criteria.type) return (cell)=>!cellText(cell).endsWith(comparableText(expected));
+    return (cell)=>{
+        const order = compareCell(cell, expected);
+        if (null === order) return false;
+        if ('equals' === criteria.type) return 0 === order;
+        if ('not-equals' === criteria.type) return 0 !== order;
+        if ('greater-than' === criteria.type) return order > 0;
+        if ('greater-than-or-equal' === criteria.type) return order >= 0;
+        if ('less-than' === criteria.type) return order < 0;
+        return order <= 0;
+    };
+}
+function compareCell(cell, expected) {
+    const value = cellValue(cell);
+    if (null === value) return null;
+    const numericExpected = finiteNumber(expected);
+    if ('number' == typeof value && null !== numericExpected) return value - numericExpected;
+    return comparableText(String(value)).localeCompare(comparableText(expected), 'zh-CN', {
+        numeric: true,
+        sensitivity: 'base'
+    });
+}
+function cellIsBlank(cell) {
+    return null === cellValue(cell);
+}
+function cellText(cell) {
+    const value = cellValue(cell);
+    return null === value ? '' : comparableText(String(value));
+}
+function cellValue(cell) {
+    const value = cell?.v ?? cell?.m;
+    if ('number' == typeof value && Number.isFinite(value)) return value;
+    if ('string' == typeof value) return '' === value ? null : value;
+    if ('boolean' == typeof value) return value;
+    return null;
+}
+function numericCellValue(cell) {
+    const value = cellValue(cell);
+    return 'number' == typeof value ? value : null;
+}
+function comparableText(value) {
+    return value.normalize('NFKC').toLocaleLowerCase('zh-CN');
+}
+function finiteNumber(value) {
+    if (!value.trim()) return null;
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : null;
+}
+function criteriaFromEntry(entry) {
+    const payload = criteriaPayloadFromEntry(entry);
+    return payload ? normalizeWorkSpreadsheetFilterCriteria(payload.criteria) : null;
+}
+function criteriaPayloadFromEntry(entry) {
+    if (!entry || 'object' != typeof entry) return null;
+    const caljs = entry.caljs;
+    if (!caljs || 'object' != typeof caljs) return null;
+    const payload = caljs;
+    if (payload.kind !== AUTO_FILTER_CRITERIA_KIND || payload.version !== AUTO_FILTER_CRITERIA_VERSION) return null;
+    return normalizeWorkSpreadsheetFilterCriteria(payload.criteria) ? payload : null;
+}
+function filterHiddenRows(filter) {
+    const rows = new Set();
+    for (const value of Object.values(filter ?? {})){
+        if (!value || 'object' != typeof value) continue;
+        const rowhidden = value.rowhidden;
+        if (rowhidden && 'object' == typeof rowhidden) for (const row of Object.keys(rowhidden))rows.add(row);
+    }
+    return rows;
+}
+function sheetCellReader(sheet) {
+    if (sheet.data) return (row, column)=>sheet.data?.[row]?.[column] ?? null;
+    const cells = new Map((sheet.celldata ?? []).map((entry)=>[
+            `${entry.r}:${entry.c}`,
+            entry.v ?? null
+        ]));
+    return (row, column)=>cells.get(`${row}:${column}`) ?? null;
+}
+function columnInRange(range, column) {
+    return Number.isSafeInteger(column) && column >= range.column[0] && column <= range.column[1];
+}
+function finiteIndex(value) {
+    return 'number' == typeof value && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function validHiddenRowKey(value) {
+    return 'string' == typeof value && /^(?:0|[1-9]\d*)$/.test(value) && Number.isSafeInteger(Number(value));
+}
+function compareHiddenRowKeys(left, right) {
+    return Number(left) - Number(right);
+}
+const work_spreadsheet_data_validation_MILLISECONDS_PER_DAY = 86400000;
 const SPREADSHEET_DATA_VALIDATION_ERROR_STYLES = [
     'stop',
     'warning',
@@ -1824,7 +3085,7 @@ function normalizeSpreadsheetDateValidationBoundary(value, uses1904DateSystem =
     if (!uses1904DateSystem && (0 === serial || 60 === serial)) return null;
     const adjustedSerial = uses1904DateSystem ? serial : serial > 60 ? serial - 1 : serial;
     const epoch = uses1904DateSystem ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 31);
-    return isoDateFromTimestamp(epoch + adjustedSerial * MILLISECONDS_PER_DAY);
+    return isoDateFromTimestamp(epoch + adjustedSerial * work_spreadsheet_data_validation_MILLISECONDS_PER_DAY);
 }
 function spreadsheetDateValidationFormula(value) {
     const normalized = normalizeIsoDate(value.trim());
@@ -2478,7 +3739,7 @@ function readRichTextRun(element, value, colors) {
     if (work_xlsx_rich_text_xlsxToggleEnabled(directChild(properties, 'b'))) run.bl = 1;
     if (work_xlsx_rich_text_xlsxToggleEnabled(directChild(properties, 'i'))) run.it = 1;
     if (work_xlsx_rich_text_xlsxToggleEnabled(directChild(properties, 'strike'))) run.cl = 1;
-    const size = finiteNumber(attribute(directChild(properties, 'sz') ?? properties, 'val'));
+    const size = work_xlsx_rich_text_finiteNumber(attribute(directChild(properties, 'sz') ?? properties, 'val'));
     if (null !== size && size >= 1 && size <= 409) run.fs = size;
     const underline = directChild(properties, 'u');
     if (underline) {
@@ -2550,7 +3811,7 @@ function work_xlsx_rich_text_xlsxToggleEnabled(element) {
     const value = attribute(element, 'val')?.trim().toLowerCase();
     return '0' !== value && 'false' !== value && 'off' !== value;
 }
-function finiteNumber(value) {
+function work_xlsx_rich_text_finiteNumber(value) {
     if (null === value || !value.trim()) return null;
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : null;
@@ -2563,4 +3824,227 @@ function work_xlsx_rich_text_nonNegativeInteger(value) {
 function work_xlsx_rich_text_isRecord(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
 }
-export { activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, coalesceXlsxRichTextRuns, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, fillSpreadsheetTableCalculatedColumns, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isHighSurrogate, isLowSurrogate, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetTableCalculatedFormula, normalizeXlsxRichTextCell, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextRun, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, reconcileSpreadsheetTableCalculatedColumns, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sameXlsxRichTextRunStyle, sheetHasXlsxRichTextCells, spreadsheetCellValueWithDiagonalBorder, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, validXlsxRichText, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };
+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 {
+    storage;
+    key;
+    constructor(storage, key = DEFAULT_SPREADSHEET_SORT_CUSTOM_LIST_STORAGE_KEY){
+        this.storage = storage;
+        this.key = key;
+    }
+    load() {
+        try {
+            const source = this.storage.getItem(this.key);
+            if (!source) return Object.freeze([]);
+            const payload = JSON.parse(source);
+            if (!spreadsheet_sort_custom_list_store_isRecord(payload) || payload.version !== SPREADSHEET_SORT_CUSTOM_LIST_STORAGE_VERSION) return Object.freeze([]);
+            return normalizeStoredSpreadsheetSortCustomLists(payload.lists);
+        } catch  {
+            return Object.freeze([]);
+        }
+    }
+    save(lists) {
+        const normalized = normalizeStoredSpreadsheetSortCustomLists(lists);
+        this.storage.setItem(this.key, JSON.stringify({
+            version: SPREADSHEET_SORT_CUSTOM_LIST_STORAGE_VERSION,
+            lists: normalized
+        }));
+    }
+}
+function normalizeStoredSpreadsheetSortCustomLists(input) {
+    if (!Array.isArray(input)) return Object.freeze([]);
+    const lists = [];
+    for (const candidate of input){
+        const validation = validateSpreadsheetSortCustomList(candidate);
+        if (!(!validation.ok || lists.some((entries)=>spreadsheetSortCustomListsEqual(entries, validation.entries)))) {
+            lists.push(Object.freeze([
+                ...validation.entries
+            ]));
+            if (lists.length >= 32) break;
+        }
+    }
+    return Object.freeze(lists);
+}
+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, workSpreadsheetCellIsDate, workSpreadsheetFilterTextCharacters, workSpreadsheetHasUnescapedWildcard, workSpreadsheetSheetWithAutoFilterCriteria, workSpreadsheetSheetWithImportedAutoFilterCriteria, workSpreadsheetSheetWithoutAutoFilterCriteria, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };