@a3s-lab/office 0.2.2 → 0.4.0

package/dist/4476.js

@@ -0,0 +1,2008 @@
+import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
+import { OFFICE_KERNEL_SPREADSHEET_MAX_ROWS } from "./5184.js";
+import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
+import { patchWorkOfficeCollaborationFlatJsonMap, readWorkOfficeCollaborationFlatJsonMap } from "./7060.js";
+import { formatSpreadsheetCellRanges, parseSpreadsheetCellRanges } from "./8715.js";
+import * as __rspack_external_yjs from "yjs";
+const MAX_POPULATED_CELLS = 1000000;
+const MAX_DENSE_MATRIX_CELLS = 1000000;
+const TRANSIENT_SHEET_FIELDS = [
+    'calcChain',
+    'dynamicArray_compute',
+    'luckysheet_select_save',
+    'luckysheet_selection_range',
+    'status',
+    'zoomRatio'
+];
+function validateWorkOfficeSpreadsheetContent(content) {
+    if (!content || 'spreadsheet' !== content.type) invalidWorkOfficeSpreadsheetInput('a Spreadsheet content value');
+    if (!Array.isArray(content.sheets)) invalidWorkOfficeSpreadsheetInput('an array of sheets');
+    const sheets = validateSheets(content.sheets);
+    const result = {
+        type: 'spreadsheet',
+        sheets
+    };
+    copyOptionalJsonField(content, result, 'calculation', 'calculation settings');
+    if (void 0 !== content.namedRanges) result.namedRanges = validateIdRecords(content.namedRanges, 'named range');
+    copyOptionalSheetSidecars(content, result, 'printAreas', 'print area');
+    copyOptionalSheetSidecars(content, result, 'printTitles', 'print titles');
+    copyOptionalSheetSidecars(content, result, 'pageBreaks', 'page breaks');
+    copyOptionalSheetSidecars(content, result, 'pageSetups', 'page setup');
+    assertSpreadsheetReferences(result);
+    return result;
+}
+function validateSharedWorkOfficeSpreadsheetContent(content) {
+    try {
+        return validateWorkOfficeSpreadsheetContent(content);
+    } catch (error) {
+        if (error instanceof WorkOfficeCollaborationError) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The shared Spreadsheet collaboration content is invalid: ${error.message}`);
+        throw error;
+    }
+}
+function invalidWorkOfficeSpreadsheetShared(label) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The shared Spreadsheet collaboration ${label} is invalid.`);
+}
+function validateSheets(value) {
+    const ids = new Set();
+    const names = new Set();
+    return value.map((candidate)=>{
+        const sheet = validateSheet(candidate);
+        const id = sheet.id;
+        if (ids.has(id)) invalidWorkOfficeSpreadsheetInput(`a unique sheet ID; '${id}' is repeated`);
+        ids.add(id);
+        const normalizedName = sheet.name.toLocaleLowerCase();
+        if (names.has(normalizedName)) invalidWorkOfficeSpreadsheetInput(`a unique sheet name; '${sheet.name}' is repeated`);
+        names.add(normalizedName);
+        return sheet;
+    });
+}
+function validateSheet(value) {
+    const source = requiredInputRecord(value, 'sheet');
+    const result = validateJsonRecord(source, 'sheet');
+    result.id = requiredIdentifier(source.id, 'sheet');
+    result.name = requiredNonEmptyString(source.name, 'sheet name');
+    for (const field of TRANSIENT_SHEET_FIELDS)delete result[field];
+    if (void 0 !== source.data) {
+        result.data = validateCellMatrix(source.data, result.id);
+        delete result.celldata;
+    } else if (void 0 !== source.celldata) {
+        result.celldata = validateSparseCells(source.celldata, result.id);
+        delete result.data;
+    }
+    validateOptionalDimension(result, 'row', OFFICE_KERNEL_SPREADSHEET_MAX_ROWS);
+    validateOptionalDimension(result, 'column', 16384);
+    if (void 0 !== source.images) result.images = validateIdRecords(source.images, `image in sheet '${result.id}'`).filter(({ id })=>!id.startsWith('work-chart-preview-'));
+    if (void 0 !== source.charts) result.charts = validateIdRecords(source.charts, `chart in sheet '${result.id}'`);
+    if (void 0 !== source.pivotTables) result.pivotTables = validateIdRecords(source.pivotTables, `pivot table in sheet '${result.id}'`);
+    if (void 0 !== source.formulaMetadata) result.formulaMetadata = validateJsonRecord(requiredInputRecord(source.formulaMetadata, 'formula metadata'), `formula metadata in sheet '${result.id}'`);
+    return result;
+}
+function validateCellMatrix(value, sheetId) {
+    if (!Array.isArray(value) || value.length > OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) invalidWorkOfficeSpreadsheetInput(`a cell matrix within the Spreadsheet row limit in sheet '${sheetId}'`);
+    let populated = 0;
+    let materialized = 0;
+    return value.map((candidate, row)=>{
+        if (!Array.isArray(candidate) || candidate.length > 16384) invalidWorkOfficeSpreadsheetInput(`a cell row within the Spreadsheet column limit at row ${row} in sheet '${sheetId}'`);
+        materialized += candidate.length;
+        if (materialized > MAX_DENSE_MATRIX_CELLS) invalidWorkOfficeSpreadsheetInput(`at most ${MAX_DENSE_MATRIX_CELLS.toLocaleString()} materialized dense cells in sheet '${sheetId}'; use celldata for larger sparse sheets`);
+        return candidate.map((cell, column)=>{
+            if (null == cell) return null;
+            populated += 1;
+            assertPopulatedCellLimit(populated, sheetId);
+            return validateCell(cell, row, column, sheetId);
+        });
+    });
+}
+function validateSparseCells(value, sheetId) {
+    if (!Array.isArray(value)) invalidWorkOfficeSpreadsheetInput(`an array of sparse cells in sheet '${sheetId}'`);
+    if (value.length > MAX_POPULATED_CELLS) assertPopulatedCellLimit(value.length, sheetId);
+    const coordinates = new Set();
+    const result = value.map((candidate)=>{
+        const record = requiredInputRecord(candidate, 'sparse cell');
+        const row = requiredCoordinate(record.r, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, 'row', sheetId);
+        const column = requiredCoordinate(record.c, 16384, 'column', sheetId);
+        const coordinate = `${row}:${column}`;
+        if (coordinates.has(coordinate)) invalidWorkOfficeSpreadsheetInput(`a unique sparse cell coordinate; '${coordinate}' is repeated in sheet '${sheetId}'`);
+        coordinates.add(coordinate);
+        return {
+            r: row,
+            c: column,
+            v: null === record.v || void 0 === record.v ? null : validateCell(record.v, row, column, sheetId)
+        };
+    });
+    return result.sort((left, right)=>left.r - right.r || left.c - right.c);
+}
+function validateCell(value, row, column, sheetId) {
+    const record = requiredInputRecord(value, 'cell');
+    return validateJsonRecord(record, `cell ${row}:${column} in sheet '${sheetId}'`);
+}
+function validateIdRecords(value, label) {
+    if (!Array.isArray(value)) invalidWorkOfficeSpreadsheetInput(`an array of ${label}s`);
+    const ids = new Set();
+    return value.map((candidate)=>{
+        const source = requiredInputRecord(candidate, label);
+        const result = validateJsonRecord(source, label);
+        result.id = requiredIdentifier(source.id, label);
+        if (ids.has(result.id)) invalidWorkOfficeSpreadsheetInput(`a unique ${label} ID; '${result.id}' is repeated`);
+        ids.add(result.id);
+        return result;
+    });
+}
+function copyOptionalSheetSidecars(source, target, key, label) {
+    const value = source[key];
+    if (void 0 === value) return;
+    if (!Array.isArray(value)) invalidWorkOfficeSpreadsheetInput(`an array of ${label} records`);
+    const sheetIds = new Set();
+    const records = value.map((candidate)=>{
+        const input = requiredInputRecord(candidate, label);
+        const record = validateJsonRecord(input, label);
+        const sheetId = requiredIdentifier(input.sheetId, `${label} sheet`);
+        if (sheetIds.has(sheetId)) invalidWorkOfficeSpreadsheetInput(`at most one ${label} record for sheet '${sheetId}'`);
+        sheetIds.add(sheetId);
+        record.sheetId = sheetId;
+        return record;
+    });
+    target[key] = records;
+}
+function copyOptionalJsonField(source, target, key, label) {
+    const value = source[key];
+    if (void 0 === value) return;
+    target[key] = validateJsonRecord(requiredInputRecord(value, label), label);
+}
+function assertSpreadsheetReferences(content) {
+    const sheetIds = new Set(content.sheets.map((sheet)=>sheet.id));
+    for (const range of content.namedRanges ?? [])if (void 0 !== range.scopeSheetId && !sheetIds.has(range.scopeSheetId)) invalidWorkOfficeSpreadsheetInput(`named range '${range.id}' to reference an existing scope sheet`);
+    for (const sheet of content.sheets)for (const pivot of sheet.pivotTables ?? [])if (!sheetIds.has(pivot.sourceSheetId)) invalidWorkOfficeSpreadsheetInput(`pivot table '${pivot.id}' to reference an existing source sheet`);
+    for (const key of [
+        'printAreas',
+        'printTitles',
+        'pageBreaks',
+        'pageSetups'
+    ])for (const record of content[key] ?? [])if (!sheetIds.has(record.sheetId)) invalidWorkOfficeSpreadsheetInput(`${key} to reference an existing sheet '${record.sheetId}'`);
+}
+function validateOptionalDimension(sheet, key, maximum) {
+    const value = sheet[key];
+    if (void 0 === value) return;
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) invalidWorkOfficeSpreadsheetInput(`a ${key} count between 0 and ${maximum} in sheet '${sheet.id}'`);
+}
+function requiredCoordinate(value, maximum, label, sheetId) {
+    if (!Number.isSafeInteger(value) || value < 0 || value >= maximum) invalidWorkOfficeSpreadsheetInput(`a valid ${label} coordinate in sheet '${sheetId}'`);
+    return value;
+}
+function requiredInputRecord(value, label) {
+    if (!isWorkOfficeCollaborationRecord(value)) invalidWorkOfficeSpreadsheetInput(`a valid ${label} record`);
+    return value;
+}
+function requiredIdentifier(value, label) {
+    const result = requiredNonEmptyString(value, `${label} ID`);
+    if (result !== result.trim() || result.length > 256) invalidWorkOfficeSpreadsheetInput(`a ${label} ID containing 1 to 256 characters`);
+    return result;
+}
+function requiredNonEmptyString(value, label) {
+    if ('string' != typeof value || !value.trim() || value.length > 256) invalidWorkOfficeSpreadsheetInput(`a non-empty string of at most 256 characters for ${label}`);
+    return value;
+}
+function validateJsonRecord(value, label) {
+    try {
+        return cloneWorkOfficeCollaborationJson(value);
+    } catch (error) {
+        throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `Spreadsheet collaboration requires a JSON-compatible ${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function assertPopulatedCellLimit(count, sheetId) {
+    if (count <= MAX_POPULATED_CELLS) return;
+    invalidWorkOfficeSpreadsheetInput(`at most ${MAX_POPULATED_CELLS.toLocaleString()} populated cells in sheet '${sheetId}'`);
+}
+function invalidWorkOfficeSpreadsheetInput(expected) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `Spreadsheet collaboration requires ${expected}.`);
+}
+function appendWorkOfficeSpreadsheetRecordClaims(claims, previous, next) {
+    const previousSheets = new Map((previous?.sheets ?? []).map((sheet)=>[
+            sheet.id,
+            sheet
+        ]));
+    for (const sheet of next.sheets){
+        const before = previousSheets.get(sheet.id);
+        if (!before) appendClaim(claims, 'sheet', sheet.id, sheet);
+        appendChildClaims(claims, before, sheet, 'image', 'images');
+        appendChildClaims(claims, before, sheet, 'chart', 'charts');
+        appendChildClaims(claims, before, sheet, 'pivot-table', 'pivotTables');
+    }
+    const previousNamedRanges = new Set((previous?.namedRanges ?? []).map(({ id })=>id));
+    for (const range of next.namedRanges ?? [])if (!previousNamedRanges.has(range.id)) appendClaim(claims, 'named-range', range.id, range);
+}
+function assertWorkOfficeSpreadsheetRecordClaims(claims, content) {
+    const fingerprints = new Map();
+    for (const raw of claims.toArray()){
+        const claim = parsedClaim(raw);
+        const identity = claimIdentity(claim.kind, claim.id, claim.parentId);
+        const existing = fingerprints.get(identity);
+        if (void 0 !== existing && existing !== claim.fingerprint) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The ${claimLabel(claim)} ID '${claim.id}' was concurrently assigned to different records.`);
+        fingerprints.set(identity, claim.fingerprint);
+    }
+    for (const sheet of content.sheets){
+        assertClaimExists(fingerprints, 'sheet', sheet.id);
+        for (const image of sheet.images ?? [])assertClaimExists(fingerprints, 'image', image.id, sheet.id);
+        for (const chart of sheet.charts ?? [])assertClaimExists(fingerprints, 'chart', chart.id, sheet.id);
+        for (const pivot of sheet.pivotTables ?? [])assertClaimExists(fingerprints, 'pivot-table', pivot.id, sheet.id);
+    }
+    for (const range of content.namedRanges ?? [])assertClaimExists(fingerprints, 'named-range', range.id);
+}
+function appendChildClaims(claims, previous, next, kind, key) {
+    const previousIds = new Set((previous?.[key] ?? []).map(({ id })=>id));
+    for (const value of next[key] ?? [])if (!previousIds.has(value.id)) appendClaim(claims, kind, value.id, value, next.id);
+}
+function appendClaim(claims, kind, id, value, parentId) {
+    const serialized = canonicalWorkOfficeCollaborationJson({
+        fingerprint: canonicalWorkOfficeCollaborationJson(value),
+        id,
+        kind,
+        ...void 0 === parentId ? {} : {
+            parentId
+        }
+    });
+    if (!claims.toArray().includes(serialized)) claims.push([
+        serialized
+    ]);
+}
+function parsedClaim(raw) {
+    if ('string' != typeof raw) invalidWorkOfficeSpreadsheetShared('record claim');
+    let value;
+    try {
+        value = JSON.parse(raw);
+    } catch  {
+        invalidWorkOfficeSpreadsheetShared('record claim');
+    }
+    if (!isWorkOfficeCollaborationRecord(value) || canonicalWorkOfficeCollaborationJson(value) !== raw) invalidWorkOfficeSpreadsheetShared('record claim');
+    const keys = Object.keys(value);
+    if (keys.some((key)=>'fingerprint' !== key && 'id' !== key && 'kind' !== key && 'parentId' !== key)) invalidWorkOfficeSpreadsheetShared('record claim');
+    const kind = requiredClaimKind(value.kind);
+    const id = requiredClaimIdentifier(value.id, 'record claim');
+    const fingerprint = requiredClaimString(value.fingerprint, 'record claim fingerprint');
+    const parentId = void 0 === value.parentId ? void 0 : requiredClaimIdentifier(value.parentId, 'record claim parent');
+    if (('sheet' === kind || 'named-range' === kind) === (void 0 !== parentId)) invalidWorkOfficeSpreadsheetShared('record claim parent');
+    try {
+        const fingerprintValue = JSON.parse(fingerprint);
+        if (canonicalWorkOfficeCollaborationJson(fingerprintValue) !== fingerprint) invalidWorkOfficeSpreadsheetShared('record claim fingerprint');
+    } catch  {
+        invalidWorkOfficeSpreadsheetShared('record claim fingerprint');
+    }
+    return {
+        fingerprint,
+        id,
+        kind,
+        parentId
+    };
+}
+function requiredClaimKind(value) {
+    if ('chart' === value || 'image' === value || 'named-range' === value || 'pivot-table' === value || 'sheet' === value) return value;
+    invalidWorkOfficeSpreadsheetShared('record claim kind');
+}
+function requiredClaimIdentifier(value, label) {
+    const result = requiredClaimString(value, label);
+    if (!result || result !== result.trim() || result.length > 256) invalidWorkOfficeSpreadsheetShared(label);
+    return result;
+}
+function requiredClaimString(value, label) {
+    if ('string' != typeof value) invalidWorkOfficeSpreadsheetShared(label);
+    return value;
+}
+function assertClaimExists(claims, kind, id, parentId) {
+    if (claims.has(claimIdentity(kind, id, parentId))) return;
+    invalidWorkOfficeSpreadsheetShared(`${claimLabel({
+        kind,
+        parentId
+    })} record claim`);
+}
+function claimIdentity(kind, id, parentId) {
+    return canonicalWorkOfficeCollaborationJson([
+        kind,
+        parentId ?? null,
+        id
+    ]);
+}
+function claimLabel(claim) {
+    if ('named-range' === claim.kind) return 'named range';
+    if ('pivot-table' === claim.kind) return `pivot table in sheet '${claim.parentId}'`;
+    if ('sheet' === claim.kind) return 'sheet';
+    return `${claim.kind} in sheet '${claim.parentId}'`;
+}
+function assertWorkOfficeSpreadsheetPatchSafe(previous, next, shared) {
+    assertCompatibleValue(previous.calculation, next.calculation, shared.calculation, 'calculation settings');
+    assertRecordCollection(previous.sheets, next.sheets, shared.sheets, (sheet)=>sheet.id, 'sheet', assertCompatibleSheet);
+    assertRecordCollection(previous.namedRanges ?? [], next.namedRanges ?? [], shared.namedRanges ?? [], (range)=>range.id, 'named range');
+    assertSheetSidecars(previous, next, shared, 'printAreas', 'print area');
+    assertSheetSidecars(previous, next, shared, 'printTitles', 'print titles');
+    assertSheetSidecars(previous, next, shared, 'pageBreaks', 'page breaks');
+    assertSheetSidecars(previous, next, shared, 'pageSetups', 'page setup');
+}
+function assertSheetSidecars(previous, next, shared, key, label) {
+    assertRecordCollection(previous[key] ?? [], next[key] ?? [], shared[key] ?? [], (record)=>record.sheetId, label);
+}
+function assertCompatibleSheet(previous, next, shared, label) {
+    const omitted = new Set([
+        'data',
+        'celldata',
+        'config',
+        'formulaMetadata',
+        'images',
+        'charts',
+        'pivotTables'
+    ]);
+    assertCompatibleValue(withoutKeys(previous, omitted), withoutKeys(next, omitted), withoutKeys(shared, omitted), label);
+    assertCompatibleValue(previous.config, next.config, shared.config, `${label} config`);
+    assertCompatibleValue(previous.formulaMetadata, next.formulaMetadata, shared.formulaMetadata, `${label} formula metadata`);
+    assertRecordCollection(previous.images ?? [], next.images ?? [], shared.images ?? [], (image)=>image.id, `${label} image`);
+    assertRecordCollection(previous.charts ?? [], next.charts ?? [], shared.charts ?? [], (chart)=>chart.id, `${label} chart`);
+    assertRecordCollection(previous.pivotTables ?? [], next.pivotTables ?? [], shared.pivotTables ?? [], (pivot)=>pivot.id, `${label} pivot table`);
+    assertCellCollection(spreadsheetCells(previous), spreadsheetCells(next), spreadsheetCells(shared), label);
+}
+function assertCellCollection(previous, next, shared, sheetLabel) {
+    for (const [coordinate, before] of previous){
+        const after = next.get(coordinate);
+        const current = shared.get(coordinate);
+        const label = `cell '${coordinate}' in ${sheetLabel}`;
+        if (void 0 === after) {
+            if (void 0 !== current && !workOfficeCollaborationJsonEqual(before, current)) conflict(label);
+            continue;
+        }
+        if (!workOfficeCollaborationJsonEqual(before, after)) {
+            if (void 0 === current) removedConflict(label);
+            assertCompatibleValue(before, after, current, label);
+        }
+    }
+    for (const [coordinate, after] of next){
+        if (previous.has(coordinate)) continue;
+        const current = shared.get(coordinate);
+        if (void 0 !== current && !workOfficeCollaborationJsonEqual(after, current)) conflict(`cell '${coordinate}' in ${sheetLabel}`);
+    }
+}
+function assertRecordCollection(previous, next, shared, identity, label, compare = assertCompatibleValue) {
+    const nextById = new Map(next.map((value)=>[
+            identity(value),
+            value
+        ]));
+    const sharedById = new Map(shared.map((value)=>[
+            identity(value),
+            value
+        ]));
+    const previousIds = new Set();
+    for (const before of previous){
+        const id = identity(before);
+        previousIds.add(id);
+        const after = nextById.get(id);
+        const current = sharedById.get(id);
+        const recordLabel = `${label} '${id}'`;
+        if (void 0 === after) {
+            if (void 0 !== current && !workOfficeCollaborationJsonEqual(before, current)) conflict(recordLabel);
+            continue;
+        }
+        if (!workOfficeCollaborationJsonEqual(before, after)) {
+            if (void 0 === current) removedConflict(recordLabel);
+            compare(before, after, current, recordLabel);
+        }
+    }
+    for (const after of next){
+        const id = identity(after);
+        if (previousIds.has(id)) continue;
+        const current = sharedById.get(id);
+        if (void 0 !== current && !workOfficeCollaborationJsonEqual(after, current)) conflict(`${label} '${id}'`);
+    }
+}
+function assertCompatibleValue(previous, next, shared, label) {
+    if (workOfficeCollaborationJsonEqual(previous, next)) return;
+    if (isWorkOfficeCollaborationRecord(previous) && isWorkOfficeCollaborationRecord(next) && isWorkOfficeCollaborationRecord(shared)) {
+        const keys = new Set([
+            ...Object.keys(previous),
+            ...Object.keys(next)
+        ]);
+        for (const key of keys){
+            const hadPrevious = Object.hasOwn(previous, key);
+            const hasNext = Object.hasOwn(next, key);
+            const hasShared = Object.hasOwn(shared, key);
+            const fieldLabel = `${label} field '${key}'`;
+            if (!hasNext) {
+                if (hadPrevious && hasShared && !workOfficeCollaborationJsonEqual(previous[key], shared[key])) conflict(fieldLabel);
+                continue;
+            }
+            if (!hadPrevious) {
+                if (hasShared && !workOfficeCollaborationJsonEqual(next[key], shared[key])) conflict(fieldLabel);
+                continue;
+            }
+            if (!workOfficeCollaborationJsonEqual(previous[key], next[key])) {
+                if (!hasShared) removedConflict(fieldLabel);
+                assertCompatibleValue(previous[key], next[key], shared[key], fieldLabel);
+            }
+        }
+        return;
+    }
+    if (!workOfficeCollaborationJsonEqual(previous, shared) && !workOfficeCollaborationJsonEqual(next, shared)) conflict(label);
+}
+function spreadsheetCells(sheet) {
+    const result = new Map();
+    if (void 0 !== sheet.data) {
+        for (const [row, values] of sheet.data.entries())for (const [column, cell] of values.entries())if (null !== cell) result.set(`${row}:${column}`, cell);
+        return result;
+    }
+    for (const entry of sheet.celldata ?? [])if (null !== entry.v) result.set(`${entry.r}:${entry.c}`, entry.v);
+    return result;
+}
+function withoutKeys(value, omitted) {
+    return Object.fromEntries(Object.entries(value).filter(([key])=>!omitted.has(key)));
+}
+function removedConflict(label) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The ${label} was removed before this change could be applied. Refresh the shared snapshot before retrying.`);
+}
+function conflict(label) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The ${label} changed concurrently. Refresh the shared snapshot before retrying.`);
+}
+function patchSpreadsheetFlatJsonMap(target, previous, next, label) {
+    patchWorkOfficeCollaborationFlatJsonMap(target, previous, next, label);
+}
+function readSpreadsheetFlatJsonMap(target, label) {
+    return readWorkOfficeCollaborationFlatJsonMap(target, label, invalidWorkOfficeSpreadsheetShared);
+}
+const SPREADSHEET_RECORD_CELLS = 'cells';
+const SPREADSHEET_RECORD_CELL_PRESENCE = 'cellPresence';
+const SPREADSHEET_RECORD_CELL_MODE = 'cellMode';
+const SPREADSHEET_RECORD_DATA_ROW_LENGTHS = 'dataRowLengths';
+function patchSpreadsheetCells(record, previous, next) {
+    const fields = nestedSpreadsheetMap(record, SPREADSHEET_RECORD_CELLS, 'sheet cell fields');
+    const presence = nestedSpreadsheetMap(record, SPREADSHEET_RECORD_CELL_PRESENCE, 'sheet cell presence');
+    const rowLengths = nestedSpreadsheetArray(record, SPREADSHEET_RECORD_DATA_ROW_LENGTHS, 'sheet data row lengths');
+    const before = spreadsheetCellEntries(previous);
+    const after = spreadsheetCellEntries(next);
+    const beforeByCoordinate = new Map(before.map((entry)=>[
+            entry.coordinate,
+            entry
+        ]));
+    const afterByCoordinate = new Map(after.map((entry)=>[
+            entry.coordinate,
+            entry
+        ]));
+    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);
+        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);
+    }
+    for (const entry of after){
+        const beforeEntry = beforeByCoordinate.get(entry.coordinate);
+        if (!(beforeEntry && workOfficeCollaborationJsonEqual(beforeEntry.cell, entry.cell))) {
+            if (beforeEntry && !presence.has(entry.coordinate)) throw staleSpreadsheetConflict(`Cell '${entry.coordinate}' in sheet '${next.id}' was removed before this change could be applied`);
+            presence.set(entry.coordinate, true);
+            patchCellFields(fields, beforeEntry?.cell, entry.cell, entry.row, entry.column, next.id);
+        }
+    }
+    patchCellProjectionMetadata(record, rowLengths, previous, next);
+}
+function readSpreadsheetCells(record, sheet) {
+    const fields = requiredSpreadsheetMap(record, SPREADSHEET_RECORD_CELLS, 'sheet cell fields');
+    const presence = requiredSpreadsheetMap(record, SPREADSHEET_RECORD_CELL_PRESENCE, 'sheet cell presence');
+    const rowLengths = requiredSpreadsheetArray(record, SPREADSHEET_RECORD_DATA_ROW_LENGTHS, 'sheet data row lengths');
+    const grouped = new Map();
+    for (const [coordinate, value] of presence.entries()){
+        if (true !== value) invalidWorkOfficeSpreadsheetShared('sheet cell presence');
+        const decoded = decodedCoordinate(coordinate);
+        grouped.set(coordinate, {
+            ...decoded,
+            cell: {},
+            coordinate
+        });
+    }
+    for (const [encoded, value] of fields.entries()){
+        const { column, row } = decodedCellField(encoded);
+        const coordinate = encodedCoordinate(row, column);
+        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);
+    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) {
+        if (entries.length > 0 || rowLengths.length > 0) invalidWorkOfficeSpreadsheetShared('cell projection mode');
+        return;
+    }
+    if ('celldata' === mode) {
+        if (rowLengths.length > 0) invalidWorkOfficeSpreadsheetShared('sparse cell projection dimensions');
+        sheet.celldata = entries.map(({ row, column, cell })=>({
+                r: row,
+                c: column,
+                v: cell
+            }));
+        return;
+    }
+    const lengths = rowLengths.toArray().map((value, row)=>{
+        if (!Number.isSafeInteger(value) || value < 0) invalidWorkOfficeSpreadsheetShared(`data row length at row ${row}`);
+        return value;
+    });
+    const data = lengths.map((length)=>Array.from({
+            length
+        }, ()=>null));
+    for (const entry of entries){
+        if (entry.row >= data.length || entry.column >= (lengths[entry.row] ?? 0)) invalidWorkOfficeSpreadsheetShared(`cell '${entry.coordinate}' outside the stored data matrix`);
+        data[entry.row][entry.column] = entry.cell;
+    }
+    sheet.data = data;
+}
+function spreadsheetCellEntries(sheet) {
+    if (!sheet) return [];
+    const entries = [];
+    if (void 0 !== sheet.data) {
+        for (const [row, values] of sheet.data.entries())for (const [column, cell] of values.entries())if (null !== cell) entries.push({
+            cell,
+            column,
+            coordinate: encodedCoordinate(row, column),
+            row
+        });
+        return entries;
+    }
+    for (const entry of sheet.celldata ?? [])if (null !== entry.v) entries.push({
+        cell: entry.v,
+        column: entry.c,
+        coordinate: encodedCoordinate(entry.r, entry.c),
+        row: entry.r
+    });
+    return entries;
+}
+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) {
+    return readSpreadsheetFlatJsonMap(new SpreadsheetCellFieldView(target, row, column), `cell '${row}:${column}'`);
+}
+function patchCellProjectionMetadata(record, rowLengths, previous, next) {
+    const previousMode = cellMode(previous);
+    const nextMode = cellMode(next);
+    if (previousMode !== nextMode) if (void 0 === nextMode) record.delete(SPREADSHEET_RECORD_CELL_MODE);
+    else record.set(SPREADSHEET_RECORD_CELL_MODE, nextMode);
+    const before = dataRowLengths(previous);
+    const after = dataRowLengths(next);
+    if (!workOfficeCollaborationJsonEqual(before, after)) {
+        const shared = rowLengths.toArray();
+        const merged = mergeStaleRowLengths(before, after, shared);
+        if (rowLengths.length > 0) rowLengths.delete(0, rowLengths.length);
+        if (merged.length > 0) rowLengths.push(merged);
+    }
+}
+function mergeStaleRowLengths(previous, next, shared) {
+    const length = Math.max(next.length, shared.length);
+    const result = [];
+    for(let index = 0; index < length; index += 1){
+        const before = previous[index];
+        const after = next[index];
+        const current = shared[index];
+        if (after === before) result[index] = current ?? after ?? 0;
+        else if (current === before || void 0 === current) result[index] = after ?? 0;
+        else result[index] = Math.max(after ?? 0, current);
+    }
+    while(result.length > next.length && 0 === result.at(-1))result.pop();
+    return result;
+}
+function cellMode(sheet) {
+    if (sheet?.data !== void 0) return 'data';
+    if (sheet?.celldata !== void 0) return 'celldata';
+}
+function dataRowLengths(sheet) {
+    return sheet?.data?.map((row)=>row.length) ?? [];
+}
+function nestedSpreadsheetMap(record, key, label) {
+    const existing = record.get(key);
+    if (existing instanceof __rspack_external_yjs.Map) return existing;
+    if (void 0 !== existing) invalidWorkOfficeSpreadsheetShared(label);
+    const value = new __rspack_external_yjs.Map();
+    record.set(key, value);
+    return value;
+}
+function nestedSpreadsheetArray(record, key, label) {
+    const existing = record.get(key);
+    if (existing instanceof __rspack_external_yjs.Array) return existing;
+    if (void 0 !== existing) invalidWorkOfficeSpreadsheetShared(label);
+    const value = new __rspack_external_yjs.Array();
+    record.set(key, value);
+    return value;
+}
+function requiredSpreadsheetMap(record, key, label) {
+    const value = record.get(key);
+    if (!(value instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(label);
+    return value;
+}
+function requiredSpreadsheetArray(record, key, label) {
+    const value = record.get(key);
+    if (!(value instanceof __rspack_external_yjs.Array)) invalidWorkOfficeSpreadsheetShared(label);
+    return value;
+}
+function optionalCellMode(value) {
+    if (void 0 === value) return;
+    if ('data' === value || 'celldata' === value) return value;
+    invalidWorkOfficeSpreadsheetShared('cell projection mode');
+}
+function encodedCoordinate(row, column) {
+    return `${row}:${column}`;
+}
+function decodedCoordinate(coordinate) {
+    const match = /^(0|[1-9]\d*):(0|[1-9]\d*)$/.exec(coordinate);
+    if (!match) invalidWorkOfficeSpreadsheetShared(`cell coordinate '${coordinate}'`);
+    const row = Number(match[1]);
+    const column = Number(match[2]);
+    if (!Number.isSafeInteger(row) || !Number.isSafeInteger(column) || row >= OFFICE_KERNEL_SPREADSHEET_MAX_ROWS || column >= 16384) invalidWorkOfficeSpreadsheetShared(`cell coordinate '${coordinate}'`);
+    return {
+        row,
+        column
+    };
+}
+function encodedCellField(row, column, key) {
+    return JSON.stringify([
+        row,
+        column,
+        key
+    ]);
+}
+class SpreadsheetCellFieldView {
+    #source;
+    #row;
+    #column;
+    constructor(source, row, column){
+        this.#source = source;
+        this.#row = row;
+        this.#column = column;
+    }
+    get(key) {
+        return this.#source.get(encodedCellField(this.#row, this.#column, key));
+    }
+    set(key, value) {
+        this.#source.set(encodedCellField(this.#row, this.#column, key), value);
+        return value;
+    }
+    delete(key) {
+        return this.#source.delete(encodedCellField(this.#row, this.#column, key));
+    }
+    *entries() {
+        for (const [encoded, value] of this.#source.entries()){
+            const identity = decodedCellField(encoded);
+            if (identity.row === this.#row && identity.column === this.#column) yield [
+                identity.key,
+                value
+            ];
+        }
+    }
+}
+function deleteCellFields(source, row, column) {
+    for (const encoded of Array.from(source.keys())){
+        const identity = decodedCellField(encoded);
+        if (identity.row === row && identity.column === column) source.delete(encoded);
+    }
+}
+function decodedCellField(encoded) {
+    let value;
+    try {
+        value = JSON.parse(encoded);
+    } catch  {
+        invalidWorkOfficeSpreadsheetShared(`cell field identity '${encoded}'`);
+    }
+    if (!Array.isArray(value) || 3 !== value.length || 'string' != typeof value[2] || !value[2] || encodedCellField(value[0], value[1], value[2]) !== encoded) invalidWorkOfficeSpreadsheetShared(`cell field identity '${encoded}'`);
+    const coordinate = decodedCoordinate(`${value[0]}:${value[1]}`);
+    return {
+        ...coordinate,
+        key: value[2]
+    };
+}
+function staleSpreadsheetConflict(message) {
+    return new WorkOfficeCollaborationError('office.collaboration.content_invalid', `${message}. Refresh the shared snapshot before retrying.`);
+}
+const SPREADSHEET_RECORD_CONFIG = 'config';
+const SPREADSHEET_RECORD_FORMULA_METADATA = 'formulaMetadata';
+const SPREADSHEET_RECORD_IMAGES = 'images';
+const SPREADSHEET_RECORD_IMAGE_ORDER = 'imageOrder';
+const SPREADSHEET_RECORD_CHARTS = 'charts';
+const SPREADSHEET_RECORD_CHART_ORDER = 'chartOrder';
+const SPREADSHEET_RECORD_PIVOTS = 'pivotTables';
+const SPREADSHEET_RECORD_PIVOT_ORDER = 'pivotOrder';
+const NESTED_SHEET_FIELDS = new Set([
+    "cells",
+    SPREADSHEET_RECORD_CELL_PRESENCE,
+    SPREADSHEET_RECORD_CELL_MODE,
+    SPREADSHEET_RECORD_DATA_ROW_LENGTHS,
+    SPREADSHEET_RECORD_CONFIG,
+    SPREADSHEET_RECORD_FORMULA_METADATA,
+    SPREADSHEET_RECORD_IMAGES,
+    SPREADSHEET_RECORD_IMAGE_ORDER,
+    SPREADSHEET_RECORD_CHARTS,
+    SPREADSHEET_RECORD_CHART_ORDER,
+    SPREADSHEET_RECORD_PIVOTS,
+    SPREADSHEET_RECORD_PIVOT_ORDER
+]);
+function initializeSpreadsheetSheetRecord(record, sheet) {
+    office_spreadsheet_collaboration_records_nestedSpreadsheetMap(record, SPREADSHEET_RECORD_CONFIG, 'sheet config');
+    office_spreadsheet_collaboration_records_nestedSpreadsheetMap(record, SPREADSHEET_RECORD_FORMULA_METADATA, 'sheet formula metadata');
+    initializeIdCollection(record, SPREADSHEET_RECORD_IMAGES, SPREADSHEET_RECORD_IMAGE_ORDER);
+    initializeIdCollection(record, SPREADSHEET_RECORD_CHARTS, SPREADSHEET_RECORD_CHART_ORDER);
+    initializeIdCollection(record, SPREADSHEET_RECORD_PIVOTS, SPREADSHEET_RECORD_PIVOT_ORDER);
+    patchSpreadsheetSheetRecord(record, void 0, sheet);
+}
+function patchSpreadsheetSheetRecord(record, previous, next) {
+    const before = previous ?? {};
+    const after = next;
+    const keys = new Set([
+        ...Object.keys(before),
+        ...Object.keys(after)
+    ]);
+    for (const key of keys)if ('data' !== key && 'celldata' !== key && 'config' !== key && 'formulaMetadata' !== key && 'images' !== key && 'charts' !== key && 'pivotTables' !== key) patchOptionalJson(record, key, before[key], after[key], void 0 !== previous);
+    patchJsonMap(office_spreadsheet_collaboration_records_nestedSpreadsheetMap(record, SPREADSHEET_RECORD_CONFIG, 'sheet config'), previous?.config, next.config);
+    patchJsonMap(office_spreadsheet_collaboration_records_nestedSpreadsheetMap(record, SPREADSHEET_RECORD_FORMULA_METADATA, 'sheet formula metadata'), previous?.formulaMetadata, next.formulaMetadata);
+    patchSpreadsheetCells(record, previous, next);
+    patchIdCollection(record, SPREADSHEET_RECORD_IMAGES, SPREADSHEET_RECORD_IMAGE_ORDER, previous?.images ?? [], next.images ?? [], `image in sheet '${next.id}'`);
+    patchIdCollection(record, SPREADSHEET_RECORD_CHARTS, SPREADSHEET_RECORD_CHART_ORDER, previous?.charts ?? [], next.charts ?? [], `chart in sheet '${next.id}'`);
+    patchIdCollection(record, SPREADSHEET_RECORD_PIVOTS, SPREADSHEET_RECORD_PIVOT_ORDER, previous?.pivotTables ?? [], next.pivotTables ?? [], `pivot table in sheet '${next.id}'`);
+}
+function readSpreadsheetSheetRecord(record, id) {
+    const result = {};
+    for (const [key, value] of record.entries())if (!NESTED_SHEET_FIELDS.has(key)) {
+        if (value instanceof __rspack_external_yjs.AbstractType) invalidWorkOfficeSpreadsheetShared(`sheet '${id}' field '${key}'`);
+        result[key] = cloneWorkOfficeCollaborationJson(value);
+    }
+    if (result.id !== id) invalidWorkOfficeSpreadsheetShared(`sheet '${id}' identity`);
+    const config = readJsonMap(office_spreadsheet_collaboration_records_requiredSpreadsheetMap(record, SPREADSHEET_RECORD_CONFIG, 'sheet config'), 'sheet config');
+    if (Object.keys(config).length > 0) result.config = config;
+    const formulaMetadata = readJsonMap(office_spreadsheet_collaboration_records_requiredSpreadsheetMap(record, SPREADSHEET_RECORD_FORMULA_METADATA, 'sheet formula metadata'), 'sheet formula metadata');
+    if (Object.keys(formulaMetadata).length > 0) result.formulaMetadata = formulaMetadata;
+    const sheet = result;
+    readSpreadsheetCells(record, sheet);
+    readOptionalCollection(record, SPREADSHEET_RECORD_IMAGES, SPREADSHEET_RECORD_IMAGE_ORDER, `image in sheet '${id}'`, 'images', result);
+    readOptionalCollection(record, SPREADSHEET_RECORD_CHARTS, SPREADSHEET_RECORD_CHART_ORDER, `chart in sheet '${id}'`, 'charts', result);
+    readOptionalCollection(record, SPREADSHEET_RECORD_PIVOTS, SPREADSHEET_RECORD_PIVOT_ORDER, `pivot table in sheet '${id}'`, 'pivotTables', result);
+    return sheet;
+}
+function patchSpreadsheetOrder(order, previous, next) {
+    if (workOfficeCollaborationJsonEqual(previous, next)) return;
+    const nextIds = new Set(next);
+    for (const id of previous)if (!nextIds.has(id)) removeAll(order, id);
+    const previousIds = new Set(previous);
+    for (const id of next)if (!previousIds.has(id) && !order.toArray().includes(id)) insertRelative(order, next, id);
+    if (!sameRelativeOrder(previous, next)) {
+        for (const id of next.filter((value)=>previousIds.has(value)))removeAll(order, id);
+        for (const id of next)if (!order.toArray().includes(id)) insertRelative(order, next, id);
+    }
+}
+function validatedSpreadsheetOrder(order, records, label) {
+    const seen = new Set();
+    const values = [];
+    for (const value of order.toArray()){
+        if ('string' != typeof value || !value.trim()) invalidWorkOfficeSpreadsheetShared(`${label} order`);
+        if (!seen.has(value)) {
+            seen.add(value);
+            values.push(value);
+        }
+    }
+    if (seen.size !== records.size || Array.from(records.keys()).some((id)=>!seen.has(id))) invalidWorkOfficeSpreadsheetShared(`${label} order and record set`);
+    return values;
+}
+function office_spreadsheet_collaboration_records_nestedSpreadsheetMap(parent, key, label) {
+    const existing = parent.get(key);
+    if (existing instanceof __rspack_external_yjs.Map) return existing;
+    if (void 0 !== existing) invalidWorkOfficeSpreadsheetShared(label);
+    const value = new __rspack_external_yjs.Map();
+    parent.set(key, value);
+    return value;
+}
+function office_spreadsheet_collaboration_records_requiredSpreadsheetMap(parent, key, label) {
+    const value = parent.get(key);
+    if (!(value instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(label);
+    return value;
+}
+function initializeIdCollection(record, recordsKey, orderKey) {
+    office_spreadsheet_collaboration_records_nestedSpreadsheetMap(record, recordsKey, recordsKey);
+    office_spreadsheet_collaboration_records_nestedSpreadsheetArray(record, orderKey, orderKey);
+}
+function patchIdCollection(parent, recordsKey, orderKey, previous, next, label) {
+    const records = office_spreadsheet_collaboration_records_nestedSpreadsheetMap(parent, recordsKey, label);
+    const order = office_spreadsheet_collaboration_records_nestedSpreadsheetArray(parent, orderKey, `${label} order`);
+    const previousById = new Map(previous.map((value)=>[
+            value.id,
+            value
+        ]));
+    const nextById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    for (const value of previous){
+        if (nextById.has(value.id)) continue;
+        const current = records.get(value.id);
+        if (!(current instanceof __rspack_external_yjs.Map)) {
+            if (void 0 === current) continue;
+            invalidWorkOfficeSpreadsheetShared(label);
+        }
+        if (!workOfficeCollaborationJsonEqual(value, readJsonMap(current, label))) throw staleConflict(`${label} '${value.id}' changed before it was deleted`);
+        records.delete(value.id);
+        removeAll(order, value.id);
+    }
+    for (const value of next){
+        const before = previousById.get(value.id);
+        if (before && workOfficeCollaborationJsonEqual(before, value)) continue;
+        let record = records.get(value.id);
+        if (void 0 === record) {
+            if (before) throw staleConflict(`${label} '${value.id}' was removed before this change`);
+            record = new __rspack_external_yjs.Map();
+            records.set(value.id, record);
+        }
+        if (!(record instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(label);
+        patchJsonMap(record, before, value);
+    }
+    patchSpreadsheetOrder(order, previous.map(({ id })=>id), next.map(({ id })=>id));
+}
+function readOptionalCollection(parent, recordsKey, orderKey, label, outputKey, output) {
+    const records = office_spreadsheet_collaboration_records_requiredSpreadsheetMap(parent, recordsKey, label);
+    const order = office_spreadsheet_collaboration_records_requiredSpreadsheetArray(parent, orderKey, `${label} order`);
+    const result = validatedSpreadsheetOrder(order, records, label).map((id)=>{
+        const record = office_spreadsheet_collaboration_records_requiredSpreadsheetMap(records, id, label);
+        const value = readJsonMap(record, label);
+        if (value.id !== id) invalidWorkOfficeSpreadsheetShared(`${label} identity`);
+        return value;
+    });
+    if (result.length > 0) output[outputKey] = result;
+}
+function patchJsonMap(target, previous, next) {
+    patchSpreadsheetFlatJsonMap(target, previous, next, 'Spreadsheet record');
+}
+function readJsonMap(target, label) {
+    return readSpreadsheetFlatJsonMap(target, label);
+}
+function patchOptionalJson(target, key, previous, next, hadPrevious) {
+    if (hadPrevious && workOfficeCollaborationJsonEqual(previous, next)) return;
+    if (void 0 === next) {
+        if (hadPrevious && !workOfficeCollaborationJsonEqual(target.get(key), previous)) throw staleConflict(`Field '${key}' changed before it was removed`);
+        target.delete(key);
+    } else target.set(key, cloneWorkOfficeCollaborationJson(next));
+}
+function office_spreadsheet_collaboration_records_nestedSpreadsheetArray(parent, key, label) {
+    const existing = parent.get(key);
+    if (existing instanceof __rspack_external_yjs.Array) return existing;
+    if (void 0 !== existing) invalidWorkOfficeSpreadsheetShared(label);
+    const value = new __rspack_external_yjs.Array();
+    parent.set(key, value);
+    return value;
+}
+function office_spreadsheet_collaboration_records_requiredSpreadsheetArray(parent, key, label) {
+    const value = parent.get(key);
+    if (!(value instanceof __rspack_external_yjs.Array)) invalidWorkOfficeSpreadsheetShared(label);
+    return value;
+}
+function removeAll(order, id) {
+    for(let index = order.length - 1; index >= 0; index -= 1)if (order.get(index) === id) order.delete(index, 1);
+}
+function insertRelative(order, desired, id) {
+    const desiredIndex = desired.indexOf(id);
+    for(let index = desiredIndex - 1; index >= 0; index -= 1){
+        const sibling = desired[index];
+        const position = order.toArray().lastIndexOf(sibling);
+        if (position >= 0) return void order.insert(position + 1, [
+            id
+        ]);
+    }
+    for(let index = desiredIndex + 1; index < desired.length; index += 1){
+        const sibling = desired[index];
+        const position = order.toArray().indexOf(sibling);
+        if (position >= 0) return void order.insert(position, [
+            id
+        ]);
+    }
+    order.push([
+        id
+    ]);
+}
+function sameRelativeOrder(previous, next) {
+    const nextIds = new Set(next);
+    const previousIds = new Set(previous);
+    return workOfficeCollaborationJsonEqual(previous.filter((id)=>nextIds.has(id)), next.filter((id)=>previousIds.has(id)));
+}
+function staleConflict(message) {
+    return new WorkOfficeCollaborationError('office.collaboration.content_invalid', `${message}. Refresh the shared snapshot before retrying.`);
+}
+const SPREADSHEET_OPTIONS_ROOT = 'spreadsheet.options';
+const SPREADSHEET_SHEETS_ROOT = 'spreadsheet.sheets';
+const SPREADSHEET_SHEET_ORDER_ROOT = 'spreadsheet.sheet-order';
+const SPREADSHEET_NAMED_RANGES_ROOT = 'spreadsheet.named-ranges';
+const SPREADSHEET_NAMED_RANGE_ORDER_ROOT = 'spreadsheet.named-range-order';
+const SPREADSHEET_RECORD_CLAIMS_ROOT = 'spreadsheet.record-claims';
+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) {
+    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))
+    };
+}
+function initializeWorkOfficeSpreadsheetRoots(roots, content) {
+    appendWorkOfficeSpreadsheetRecordClaims(roots.recordClaims, void 0, content);
+    patchSpreadsheetFlatJsonMap(roots.options, void 0, content.calculation, 'calculation settings');
+    patchSheets(roots, void 0, content);
+    patchIdRecords(roots.namedRanges, roots.namedRangeOrder, [], content.namedRanges ?? [], 'named range');
+    patchSheetSidecars(roots.printAreas, [], content.printAreas ?? [], 'print area');
+    patchSheetSidecars(roots.printTitles, [], content.printTitles ?? [], 'print titles');
+    patchSheetSidecars(roots.pageBreaks, [], content.pageBreaks ?? [], 'page breaks');
+    patchSheetSidecars(roots.pageSetups, [], content.pageSetups ?? [], 'page setup');
+}
+function readWorkOfficeSpreadsheetRoots(roots) {
+    const result = {
+        type: 'spreadsheet',
+        sheets: validatedSpreadsheetOrder(roots.sheetOrder, roots.sheets, 'sheet').map((id)=>readSpreadsheetSheetRecord(office_spreadsheet_collaboration_records_requiredSpreadsheetMap(roots.sheets, id, `sheet '${id}'`), id))
+    };
+    const calculation = readSpreadsheetFlatJsonMap(roots.options, 'calculation settings');
+    if (Object.keys(calculation).length > 0) result.calculation = calculation;
+    const namedRanges = readIdRecords(roots.namedRanges, roots.namedRangeOrder, 'named range');
+    if (namedRanges.length > 0) result.namedRanges = namedRanges;
+    readSheetSidecars(roots.printAreas, 'printAreas', 'print area', result);
+    readSheetSidecars(roots.printTitles, 'printTitles', 'print titles', result);
+    readSheetSidecars(roots.pageBreaks, 'pageBreaks', 'page breaks', result);
+    readSheetSidecars(roots.pageSetups, 'pageSetups', 'page setup', result);
+    const validated = validateSharedWorkOfficeSpreadsheetContent(result);
+    assertWorkOfficeSpreadsheetRecordClaims(roots.recordClaims, validated);
+    return validated;
+}
+function patchWorkOfficeSpreadsheetRoots(roots, previous, next) {
+    const shared = readWorkOfficeSpreadsheetRoots(roots);
+    assertWorkOfficeSpreadsheetPatchSafe(previous, next, shared);
+    appendWorkOfficeSpreadsheetRecordClaims(roots.recordClaims, previous, next);
+    patchSpreadsheetFlatJsonMap(roots.options, previous.calculation, next.calculation, 'calculation settings');
+    patchSheets(roots, previous, next);
+    patchIdRecords(roots.namedRanges, roots.namedRangeOrder, previous.namedRanges ?? [], next.namedRanges ?? [], 'named range');
+    patchSheetSidecars(roots.printAreas, previous.printAreas ?? [], next.printAreas ?? [], 'print area');
+    patchSheetSidecars(roots.printTitles, previous.printTitles ?? [], next.printTitles ?? [], 'print titles');
+    patchSheetSidecars(roots.pageBreaks, previous.pageBreaks ?? [], next.pageBreaks ?? [], 'page breaks');
+    patchSheetSidecars(roots.pageSetups, previous.pageSetups ?? [], next.pageSetups ?? [], 'page setup');
+}
+function assertWorkOfficeSpreadsheetRootsEmpty(roots) {
+    if (roots.options.size > 0 || roots.sheets.size > 0 || roots.sheetOrder.length > 0 || roots.namedRanges.size > 0 || roots.namedRangeOrder.length > 0 || roots.recordClaims.length > 0 || roots.printAreas.size > 0 || roots.printTitles.size > 0 || roots.pageBreaks.size > 0 || roots.pageSetups.size > 0) throw new WorkOfficeCollaborationError('office.collaboration.bootstrap_ambiguous', 'The Spreadsheet collaboration roots contain data without initialized metadata.');
+}
+function workOfficeSpreadsheetUndoScope(roots) {
+    const scope = [
+        roots.options,
+        roots.sheets,
+        roots.sheetOrder,
+        roots.namedRanges,
+        roots.namedRangeOrder,
+        roots.recordClaims,
+        roots.printAreas,
+        roots.printTitles,
+        roots.pageBreaks,
+        roots.pageSetups
+    ];
+    return scope;
+}
+function patchSheets(roots, previous, next) {
+    const before = previous?.sheets ?? [];
+    const beforeById = new Map(before.map((sheet)=>[
+            sheet.id,
+            sheet
+        ]));
+    const afterById = new Map(next.sheets.map((sheet)=>[
+            sheet.id,
+            sheet
+        ]));
+    for (const sheet of before){
+        const id = sheet.id;
+        if (afterById.has(id)) continue;
+        const current = roots.sheets.get(id);
+        if (void 0 !== current) {
+            if (!(current instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(`sheet '${id}'`);
+            if (!workOfficeCollaborationJsonEqual(sheet, readSpreadsheetSheetRecord(current, id))) throw office_spreadsheet_collaboration_model_staleConflict(`Sheet '${id}' changed before it was deleted`);
+            roots.sheets.delete(id);
+            office_spreadsheet_collaboration_model_removeAll(roots.sheetOrder, id);
+        }
+    }
+    for (const sheet of next.sheets){
+        const id = sheet.id;
+        const beforeSheet = beforeById.get(id);
+        if (beforeSheet && workOfficeCollaborationJsonEqual(beforeSheet, sheet)) continue;
+        let record = roots.sheets.get(id);
+        if (void 0 === record) {
+            if (beforeSheet) throw office_spreadsheet_collaboration_model_staleConflict(`Sheet '${id}' was removed before this change`);
+            record = new __rspack_external_yjs.Map();
+            roots.sheets.set(id, record);
+            initializeSpreadsheetSheetRecord(record, sheet);
+            continue;
+        }
+        if (!(record instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(`sheet '${id}'`);
+        patchSpreadsheetSheetRecord(record, beforeSheet, sheet);
+    }
+    patchSpreadsheetOrder(roots.sheetOrder, before.map((sheet)=>sheet.id), next.sheets.map((sheet)=>sheet.id));
+}
+function patchIdRecords(records, order, previous, next, label) {
+    const beforeById = new Map(previous.map((value)=>[
+            value.id,
+            value
+        ]));
+    const afterById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    for (const value of previous){
+        if (afterById.has(value.id)) continue;
+        const current = records.get(value.id);
+        if (void 0 !== current) {
+            if (!(current instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(label);
+            if (!workOfficeCollaborationJsonEqual(value, readSpreadsheetFlatJsonMap(current, label))) throw office_spreadsheet_collaboration_model_staleConflict(`${label} '${value.id}' changed before it was deleted`);
+            records.delete(value.id);
+            office_spreadsheet_collaboration_model_removeAll(order, value.id);
+        }
+    }
+    for (const value of next){
+        const before = beforeById.get(value.id);
+        if (before && workOfficeCollaborationJsonEqual(before, value)) continue;
+        let record = records.get(value.id);
+        if (void 0 === record) {
+            if (before) throw office_spreadsheet_collaboration_model_staleConflict(`${label} '${value.id}' was removed before this change`);
+            record = new __rspack_external_yjs.Map();
+            records.set(value.id, record);
+        }
+        if (!(record instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(label);
+        patchSpreadsheetFlatJsonMap(record, before, value, label);
+    }
+    patchSpreadsheetOrder(order, previous.map(({ id })=>id), next.map(({ id })=>id));
+}
+function readIdRecords(records, order, label) {
+    return validatedSpreadsheetOrder(order, records, label).map((id)=>{
+        const value = readSpreadsheetFlatJsonMap(office_spreadsheet_collaboration_records_requiredSpreadsheetMap(records, id, label), label);
+        if (value.id !== id) invalidWorkOfficeSpreadsheetShared(`${label} identity`);
+        return value;
+    });
+}
+function patchSheetSidecars(records, previous, next, label) {
+    const beforeBySheet = new Map(previous.map((value)=>[
+            value.sheetId,
+            value
+        ]));
+    const afterBySheet = new Map(next.map((value)=>[
+            value.sheetId,
+            value
+        ]));
+    for (const value of previous){
+        if (afterBySheet.has(value.sheetId)) continue;
+        const current = records.get(value.sheetId);
+        if (void 0 !== current) {
+            if (!(current instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(label);
+            if (!workOfficeCollaborationJsonEqual(value, readSpreadsheetFlatJsonMap(current, label))) throw office_spreadsheet_collaboration_model_staleConflict(`${label} for sheet '${value.sheetId}' changed before deletion`);
+            records.delete(value.sheetId);
+        }
+    }
+    for (const value of next){
+        const before = beforeBySheet.get(value.sheetId);
+        if (before && workOfficeCollaborationJsonEqual(before, value)) continue;
+        let record = records.get(value.sheetId);
+        if (void 0 === record) {
+            if (before) throw office_spreadsheet_collaboration_model_staleConflict(`${label} for sheet '${value.sheetId}' was removed`);
+            record = new __rspack_external_yjs.Map();
+            records.set(value.sheetId, record);
+        }
+        if (!(record instanceof __rspack_external_yjs.Map)) invalidWorkOfficeSpreadsheetShared(label);
+        patchSpreadsheetFlatJsonMap(record, before, value, label);
+    }
+}
+function readSheetSidecars(records, key, label, output) {
+    const result = Array.from(records.keys()).sort().map((sheetId)=>{
+        const value = readSpreadsheetFlatJsonMap(office_spreadsheet_collaboration_records_requiredSpreadsheetMap(records, sheetId, label), label);
+        if (value.sheetId !== sheetId) invalidWorkOfficeSpreadsheetShared(`${label} identity`);
+        return value;
+    });
+    if (result.length > 0) output[key] = result;
+}
+function office_spreadsheet_collaboration_model_removeAll(order, id) {
+    for(let index = order.length - 1; index >= 0; index -= 1)if (order.get(index) === id) order.delete(index, 1);
+}
+function office_spreadsheet_collaboration_model_staleConflict(message) {
+    return new WorkOfficeCollaborationError('office.collaboration.content_invalid', `${message}. Refresh the shared snapshot before retrying.`);
+}
+function initializeWorkOfficeSpreadsheetCollaboration(session, content) {
+    assertSpreadsheetSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const prepared = validateWorkOfficeSpreadsheetContent(content);
+    const existing = readWorkOfficeCollaborationMetadata(session);
+    if (existing?.initialized) return {
+        initialized: false,
+        content: readWorkOfficeSpreadsheetCollaboration(session)
+    };
+    const roots = spreadsheetRoots(session);
+    assertWorkOfficeSpreadsheetRootsEmpty(roots);
+    const origin = session.createOrigin('bootstrap');
+    session.transact(()=>{
+        const metadata = initializeWorkOfficeCollaborationMetadata(session);
+        if (metadata.initialized) return;
+        registerWorkOfficeCollaborationInitializer(session);
+        initializeWorkOfficeSpreadsheetRoots(roots, prepared);
+        markWorkOfficeCollaborationInitialized(session);
+    }, origin);
+    return {
+        initialized: true,
+        content: readWorkOfficeSpreadsheetCollaboration(session)
+    };
+}
+function readWorkOfficeSpreadsheetCollaboration(session) {
+    assertInitializedSpreadsheetSession(session);
+    return readWorkOfficeSpreadsheetRoots(spreadsheetRoots(session));
+}
+function replaceWorkOfficeSpreadsheetCollaboration(session, previous, next, origin = session.localOrigin) {
+    assertInitializedSpreadsheetSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const before = validateWorkOfficeSpreadsheetContent(previous);
+    const after = validateWorkOfficeSpreadsheetContent(next);
+    if (workOfficeCollaborationJsonEqual(before, after)) return false;
+    session.transact(()=>{
+        patchWorkOfficeSpreadsheetRoots(spreadsheetRoots(session), before, after);
+    }, origin);
+    return true;
+}
+function createWorkOfficeSpreadsheetCollaborationBinding(session, options = {}) {
+    assertInitializedSpreadsheetSession(session);
+    return new WorkOfficeSpreadsheetCollaborationBindingImpl(session, options);
+}
+class WorkOfficeSpreadsheetCollaborationBindingImpl {
+    origin;
+    #session;
+    #undoManager;
+    #roots;
+    #undoScope;
+    #listeners = new Set();
+    #errorListeners = new Set();
+    #historyListeners = new Set();
+    #destroyed = false;
+    #pendingChange = false;
+    #pendingLocal = true;
+    #pendingOrigin;
+    constructor(session, options){
+        this.#session = session;
+        this.#roots = spreadsheetRoots(session);
+        this.origin = options.origin ?? session.createOrigin(session.localOrigin.kind);
+        assertWorkOfficeCollaborationOrigin(this.origin);
+        this.#undoScope = workOfficeSpreadsheetUndoScope(this.#roots);
+        this.#undoManager = new __rspack_external_yjs.UndoManager(this.#undoScope, {
+            captureTimeout: options.captureTimeoutMs ?? 500,
+            trackedOrigins: new Set([
+                this.origin
+            ])
+        });
+        session.document.on('afterTransaction', this.#onTransaction);
+        this.#undoManager.on('stack-item-added', this.#onHistoryChange);
+        this.#undoManager.on('stack-item-popped', this.#onHistoryChange);
+        this.#undoManager.on('stack-item-updated', this.#onHistoryChange);
+    }
+    content() {
+        this.ensureActive();
+        return readWorkOfficeSpreadsheetRoots(this.#roots);
+    }
+    replace(previous, next) {
+        this.ensureActive();
+        return replaceWorkOfficeSpreadsheetCollaboration(this.#session, previous, next, this.origin);
+    }
+    canUndo() {
+        this.ensureActive();
+        return this.#undoManager.canUndo();
+    }
+    canRedo() {
+        this.ensureActive();
+        return this.#undoManager.canRedo();
+    }
+    undo() {
+        this.ensureActive();
+        assertWorkOfficeCollaborationEditable(this.#session);
+        return null !== this.#undoManager.undo();
+    }
+    redo() {
+        this.ensureActive();
+        assertWorkOfficeCollaborationEditable(this.#session);
+        return null !== this.#undoManager.redo();
+    }
+    stopCapturing() {
+        this.ensureActive();
+        this.#undoManager.stopCapturing();
+    }
+    subscribe(listener) {
+        this.ensureActive();
+        this.#listeners.add(listener);
+        return ()=>this.#listeners.delete(listener);
+    }
+    subscribeError(listener) {
+        this.ensureActive();
+        this.#errorListeners.add(listener);
+        return ()=>this.#errorListeners.delete(listener);
+    }
+    subscribeHistory(listener) {
+        this.ensureActive();
+        this.#historyListeners.add(listener);
+        return ()=>this.#historyListeners.delete(listener);
+    }
+    destroy() {
+        if (this.#destroyed) return;
+        this.#destroyed = true;
+        this.#pendingChange = false;
+        this.#session.document.off('afterTransaction', this.#onTransaction);
+        this.#undoManager.off('stack-item-added', this.#onHistoryChange);
+        this.#undoManager.off('stack-item-popped', this.#onHistoryChange);
+        this.#undoManager.off('stack-item-updated', this.#onHistoryChange);
+        this.#undoManager.destroy();
+        this.#listeners.clear();
+        this.#errorListeners.clear();
+        this.#historyListeners.clear();
+    }
+    #onTransaction = (transaction)=>{
+        const changedParents = new Set(transaction.changedParentTypes.keys());
+        if (this.#destroyed || !this.#undoScope.some((root)=>changedParents.has(root))) return;
+        const local = transaction.origin === this.origin || transaction.origin === this.#undoManager;
+        this.#pendingLocal = this.#pendingChange ? this.#pendingLocal && local : local;
+        this.#pendingOrigin = transaction.origin;
+        if (this.#pendingChange) return;
+        this.#pendingChange = true;
+        queueMicrotask(this.#flushChange);
+    };
+    #flushChange = ()=>{
+        if (this.#destroyed || !this.#pendingChange) return;
+        const local = this.#pendingLocal;
+        const origin = this.#pendingOrigin;
+        this.#pendingChange = false;
+        this.#pendingLocal = true;
+        this.#pendingOrigin = void 0;
+        try {
+            const change = {
+                content: this.content(),
+                local,
+                origin
+            };
+            for (const listener of this.#listeners)listener(change);
+        } catch (error) {
+            for (const listener of this.#errorListeners)listener(error);
+        }
+    };
+    #onHistoryChange = ()=>{
+        for (const listener of this.#historyListeners)listener();
+    };
+    ensureActive() {
+        if (!this.#destroyed) return;
+        throw new WorkOfficeCollaborationError('office.collaboration.binding_destroyed', 'The Spreadsheet collaboration binding has been destroyed.');
+    }
+}
+function spreadsheetRoots(session) {
+    return workOfficeSpreadsheetRoots(session.document, session.rootName.bind(session));
+}
+function assertSpreadsheetSession(session) {
+    if ('spreadsheet' === session.kind) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.kind_mismatch', `A Spreadsheet collaboration binding cannot use a '${session.kind}' session.`);
+}
+function assertInitializedSpreadsheetSession(session) {
+    assertSpreadsheetSession(session);
+    const metadata = readWorkOfficeCollaborationMetadata(session);
+    if (metadata?.initialized) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.not_initialized', 'The Spreadsheet collaboration session has not been initialized.');
+}
+const DEFAULT_PROTECTION_HINT = '此工作表已受保护。若要更改锁定的单元格，请先取消工作表保护。';
+function defaultSheetProtectionAuthority(enabled = false) {
+    return {
+        sheet: enabled ? 1 : 0,
+        selectLockedCells: 1,
+        selectunLockedCells: 1,
+        formatCells: 0,
+        formatColumns: 0,
+        formatRows: 0,
+        insertColumns: 0,
+        insertRows: 0,
+        insertHyperlinks: 0,
+        deleteColumns: 0,
+        deleteRows: 0,
+        sort: 0,
+        filter: 0,
+        usePivotTablereports: 0,
+        editObjects: 0,
+        editScenarios: 0,
+        hintText: '',
+        defaultSheetHintText: DEFAULT_PROTECTION_HINT,
+        allowRangeList: []
+    };
+}
+function sheetProtectionAuthority(sheet) {
+    return normalizeSheetProtectionAuthority(sheet.config?.authority);
+}
+function normalizeSheetProtectionAuthority(source) {
+    const defaults = defaultSheetProtectionAuthority();
+    if (!source || 'object' != typeof source) return defaults;
+    const authority = source;
+    return {
+        sheet: flag(authority.sheet, defaults.sheet),
+        selectLockedCells: flag(authority.selectLockedCells, defaults.selectLockedCells),
+        selectunLockedCells: flag(authority.selectunLockedCells, defaults.selectunLockedCells),
+        formatCells: flag(authority.formatCells, defaults.formatCells),
+        formatColumns: flag(authority.formatColumns, defaults.formatColumns),
+        formatRows: flag(authority.formatRows, defaults.formatRows),
+        insertColumns: flag(authority.insertColumns, defaults.insertColumns),
+        insertRows: flag(authority.insertRows, defaults.insertRows),
+        insertHyperlinks: flag(authority.insertHyperlinks, defaults.insertHyperlinks),
+        deleteColumns: flag(authority.deleteColumns, defaults.deleteColumns),
+        deleteRows: flag(authority.deleteRows, defaults.deleteRows),
+        sort: flag(authority.sort, defaults.sort),
+        filter: flag(authority.filter, defaults.filter),
+        usePivotTablereports: flag(authority.usePivotTablereports, defaults.usePivotTablereports),
+        editObjects: flag(authority.editObjects, defaults.editObjects),
+        editScenarios: flag(authority.editScenarios, defaults.editScenarios),
+        hintText: stringValue(authority.hintText),
+        defaultSheetHintText: stringValue(authority.defaultSheetHintText) || DEFAULT_PROTECTION_HINT,
+        allowRangeList: editableRangeList(authority.allowRangeList),
+        xlsxAttributes: stringRecord(authority.xlsxAttributes)
+    };
+}
+function withSheetProtection(sheet, enabled) {
+    const authority = sheetProtectionAuthority(sheet);
+    authority.sheet = enabled ? 1 : 0;
+    return withAuthority(sheet, authority);
+}
+function withSheetSelectionPermissions(sheet, permissions) {
+    const authority = sheetProtectionAuthority(sheet);
+    if (void 0 !== permissions.selectLockedCells) authority.selectLockedCells = permissions.selectLockedCells ? 1 : 0;
+    if (void 0 !== permissions.selectUnlockedCells) authority.selectunLockedCells = permissions.selectUnlockedCells ? 1 : 0;
+    return withAuthority(sheet, authority);
+}
+function withEditableRange(sheet, index, editableRange) {
+    const authority = sheetProtectionAuthority(sheet);
+    const nextRange = {
+        name: editableRange.name.trim(),
+        sqref: canonicalRangeReference(editableRange.sqref),
+        hintText: editableRange.hintText?.trim() || void 0,
+        xlsxAttributes: editableRange.xlsxAttributes
+    };
+    if (null !== index && authority.allowRangeList[index]) authority.allowRangeList[index] = nextRange;
+    else authority.allowRangeList.push(nextRange);
+    const ranges = parseSpreadsheetCellRanges(nextRange.sqref) ?? [];
+    return withAuthority(withCellProtection(sheet, ranges, false), authority);
+}
+function withoutEditableRange(sheet, index) {
+    const authority = sheetProtectionAuthority(sheet);
+    const removed = authority.allowRangeList[index];
+    if (!removed) return sheet;
+    authority.allowRangeList.splice(index, 1);
+    const removedRanges = parseSpreadsheetCellRanges(removed.sqref) ?? [];
+    let next = withCellProtection(sheet, removedRanges, true);
+    for (const editableRange of authority.allowRangeList)if (!editableRangeRequiresCredentials(editableRange)) next = withCellProtection(next, parseSpreadsheetCellRanges(editableRange.sqref) ?? [], false);
+    return withAuthority(next, authority);
+}
+function withCellProtection(sheet, ranges, locked, hidden = false) {
+    if (!ranges.length) return sheet;
+    const data = cloneMatrix(sheet.data);
+    let rowCount = Math.max(sheet.row ?? 0, data.length);
+    let columnCount = Math.max(sheet.column ?? 0, ...data.map((row)=>row.length));
+    for (const range of ranges){
+        rowCount = Math.max(rowCount, range.row[1] + 1);
+        columnCount = Math.max(columnCount, range.column[1] + 1);
+        for(let row = range.row[0]; row <= range.row[1]; row += 1){
+            data[row] ??= [];
+            for(let column = range.column[0]; column <= range.column[1]; column += 1){
+                const cell = {
+                    ...data[row][column] ?? {}
+                };
+                cell.lo = locked ? 1 : 0;
+                if (hidden) cell.hi = 1;
+                else if (void 0 !== cell.hi) delete cell.hi;
+                data[row][column] = cell;
+            }
+        }
+    }
+    normalizeMatrix(data, rowCount, columnCount);
+    return {
+        ...sheet,
+        row: rowCount,
+        column: columnCount,
+        data
+    };
+}
+function applySpreadsheetCellProtectionRanges(data, ranges, rowCount, columnCount) {
+    for (const item of ranges){
+        const lastRow = Math.min(item.range.row[1], rowCount - 1);
+        const lastColumn = Math.min(item.range.column[1], columnCount - 1);
+        for(let row = Math.max(0, item.range.row[0]); row <= lastRow; row += 1){
+            data[row] ??= [];
+            for(let column = Math.max(0, item.range.column[0]); column <= lastColumn; column += 1){
+                const cell = {
+                    ...data[row][column] ?? {}
+                };
+                cell.lo = item.locked ? 1 : 0;
+                if (item.hidden) cell.hi = 1;
+                else if (void 0 !== cell.hi) delete cell.hi;
+                data[row][column] = cell;
+            }
+        }
+    }
+}
+function applyPasswordlessEditableRanges(data, ranges, rowCount, columnCount) {
+    const protectionRanges = ranges.filter((range)=>!editableRangeRequiresCredentials(range)).flatMap((range)=>parseSpreadsheetCellRanges(range.sqref) ?? []).map((range)=>({
+            range,
+            locked: false,
+            hidden: false
+        }));
+    applySpreadsheetCellProtectionRanges(data, protectionRanges, rowCount, columnCount);
+}
+function editableRangeRequiresCredentials(range) {
+    const attributes = range.xlsxAttributes ?? {};
+    return Boolean(attributes.password || attributes.hashValue || attributes.saltValue || attributes.securityDescriptor || attributes.securitydescriptor);
+}
+function sheetHasProtectionState(sheet) {
+    const authority = sheetProtectionAuthority(sheet);
+    if (1 === authority.sheet || authority.allowRangeList.length || Object.keys(authority.xlsxAttributes ?? {}).length) return true;
+    return (sheet.data ?? []).some((row)=>row.some((cell)=>cell?.lo !== void 0 || cell?.hi !== void 0));
+}
+function protectedSheetCount(sheets) {
+    return sheets.filter((sheet)=>1 === sheetProtectionAuthority(sheet).sheet).length;
+}
+function unlockedCellCount(sheet) {
+    return (sheet.data ?? []).reduce((total, row)=>total + row.reduce((rowTotal, cell)=>rowTotal + (cell?.lo === 0 ? 1 : 0), 0), 0);
+}
+function spreadsheetProtectionKey(sheets) {
+    return sheets.map((sheet)=>{
+        const authority = sheetProtectionAuthority(sheet);
+        const cells = [];
+        for (const [row, values] of (sheet.data ?? []).entries())for (const [column, cell] of values.entries()){
+            const hidden = cell?.hi;
+            if (cell?.lo !== void 0 || void 0 !== hidden) cells.push(`${row}_${column}:${cell?.lo ?? ''}:${hidden ?? ''}`);
+        }
+        return `${sheet.id ?? sheet.name}:${JSON.stringify(authority)}:${cells.join(',')}`;
+    }).join('|');
+}
+function editableRangeCellCount(ranges) {
+    return ranges.reduce((total, range)=>total + (range.row[1] - range.row[0] + 1) * (range.column[1] - range.column[0] + 1), 0);
+}
+function withAuthority(sheet, authority) {
+    return {
+        ...sheet,
+        config: {
+            ...sheet.config ?? {},
+            authority
+        }
+    };
+}
+function editableRangeList(value) {
+    if (!Array.isArray(value)) return [];
+    return value.flatMap((item, index)=>{
+        if (!item || 'object' != typeof item) return [];
+        const range = item;
+        const sqref = stringValue(range.sqref);
+        if (!sqref || !parseSpreadsheetCellRanges(sqref)) return [];
+        return [
+            {
+                name: stringValue(range.name) || `Range ${index + 1}`,
+                sqref: canonicalRangeReference(sqref),
+                hintText: stringValue(range.hintText) || void 0,
+                xlsxAttributes: stringRecord(range.xlsxAttributes)
+            }
+        ];
+    });
+}
+function canonicalRangeReference(value) {
+    const ranges = parseSpreadsheetCellRanges(value);
+    return ranges ? formatSpreadsheetCellRanges(ranges) : value.trim();
+}
+function cloneMatrix(source) {
+    return (source ?? []).map((row)=>[
+            ...row
+        ]);
+}
+function normalizeMatrix(data, rows, columns) {
+    while(data.length < rows)data.push([]);
+    for(let index = 0; index < data.length; index += 1){
+        const row = data[index] ?? [];
+        data[index] = row;
+        while(row.length < columns)row.push(null);
+    }
+}
+function flag(value, fallback) {
+    if (1 === value || true === value || '1' === value) return 1;
+    if (0 === value || false === value || '0' === value) return 0;
+    return fallback;
+}
+function stringValue(value) {
+    return 'string' == typeof value ? value : '';
+}
+function stringRecord(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return;
+    const entries = Object.entries(value).filter((entry)=>'string' == typeof entry[1]);
+    return entries.length ? Object.fromEntries(entries) : void 0;
+}
+const SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS = [
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'equal',
+    'notEqual',
+    'between',
+    'notBetween'
+];
+function isSpreadsheetConditionalComparisonOperator(value) {
+    return SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS.some((operator)=>operator === value);
+}
+function spreadsheetConditionalComparisonNeedsUpperValue(operator) {
+    return 'between' === operator || 'notBetween' === operator;
+}
+const DEFAULT_DATA_BAR_MIN_LENGTH = 10;
+const DEFAULT_DATA_BAR_MAX_LENGTH = 90;
+function defaultSpreadsheetColorScaleThresholds(colorCount) {
+    return 3 === colorCount ? [
+        {
+            type: 'min'
+        },
+        {
+            type: 'percentile',
+            value: 50
+        },
+        {
+            type: 'max'
+        }
+    ] : [
+        {
+            type: 'min'
+        },
+        {
+            type: 'max'
+        }
+    ];
+}
+function defaultSpreadsheetDataBarOptions() {
+    return {
+        thresholds: [
+            {
+                type: 'min'
+            },
+            {
+                type: 'max'
+            }
+        ],
+        showValue: true,
+        minLength: DEFAULT_DATA_BAR_MIN_LENGTH,
+        maxLength: DEFAULT_DATA_BAR_MAX_LENGTH
+    };
+}
+function normalizeSpreadsheetConditionalThreshold(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    if (![
+        'min',
+        'max',
+        'num',
+        'percent',
+        'percentile'
+    ].includes(String(source.type))) return null;
+    const type = source.type;
+    if ('min' === type || 'max' === type) return {
+        type
+    };
+    if ('number' != typeof source.value || !Number.isFinite(source.value)) return null;
+    return {
+        type,
+        value: source.value
+    };
+}
+function normalizeSpreadsheetConditionalVisualOptions(value, expectedThresholdCount, kind) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    if (!Array.isArray(source.thresholds) || source.thresholds.length !== expectedThresholdCount) return null;
+    const thresholds = source.thresholds.map(normalizeSpreadsheetConditionalThreshold);
+    if (thresholds.some((threshold)=>!threshold)) return null;
+    if ('colorScale' === kind) return {
+        thresholds: thresholds
+    };
+    const minLength = source.minLength ?? DEFAULT_DATA_BAR_MIN_LENGTH;
+    const maxLength = source.maxLength ?? DEFAULT_DATA_BAR_MAX_LENGTH;
+    if ('number' != typeof minLength || !Number.isFinite(minLength) || minLength < 0 || minLength > 100 || 'number' != typeof maxLength || !Number.isFinite(maxLength) || maxLength < 0 || maxLength > 100 || minLength > maxLength) return null;
+    return {
+        thresholds: thresholds,
+        showValue: false !== source.showValue,
+        minLength,
+        maxLength
+    };
+}
+function spreadsheetConditionalThresholdValue(threshold, sourceValues) {
+    const values = sourceValues.filter(Number.isFinite).sort((left, right)=>left - right);
+    if (!values.length) return null;
+    const minimum = values[0];
+    const maximum = values.at(-1);
+    if ('min' === threshold.type) return minimum;
+    if ('max' === threshold.type) return maximum;
+    if ('num' === threshold.type) return threshold.value ?? null;
+    const percentage = threshold.value;
+    if (void 0 === percentage || !Number.isFinite(percentage)) return null;
+    if ('percent' === threshold.type) return minimum + (maximum - minimum) * percentage / 100;
+    const position = Math.max(0, Math.min(100, percentage)) / 100 * (values.length - 1);
+    const lower = Math.floor(position);
+    const upper = Math.ceil(position);
+    if (lower === upper) return values[lower];
+    return values[lower] + (values[upper] - values[lower]) * (position - lower);
+}
+function spreadsheetConditionalThresholdsEqual(left, right) {
+    return left.length === right.length && left.every((threshold, index)=>threshold.type === right[index]?.type && threshold.value === right[index]?.value);
+}
+const SPREADSHEET_CONDITIONAL_ICON_SETS = [
+    {
+        name: '3Arrows',
+        label: '三向彩色箭头',
+        count: 3
+    },
+    {
+        name: '3ArrowsGray',
+        label: '三向灰色箭头',
+        count: 3
+    },
+    {
+        name: '3Flags',
+        label: '三色旗帜',
+        count: 3
+    },
+    {
+        name: '3TrafficLights1',
+        label: '三色交通灯（实心）',
+        count: 3
+    },
+    {
+        name: '3TrafficLights2',
+        label: '三色交通灯（边框）',
+        count: 3
+    },
+    {
+        name: '3Signs',
+        label: '三色标志',
+        count: 3
+    },
+    {
+        name: '3Symbols',
+        label: '三色符号（圆形）',
+        count: 3
+    },
+    {
+        name: '3Symbols2',
+        label: '三色符号',
+        count: 3
+    },
+    {
+        name: '4Arrows',
+        label: '四向彩色箭头',
+        count: 4
+    },
+    {
+        name: '4ArrowsGray',
+        label: '四向灰色箭头',
+        count: 4
+    },
+    {
+        name: '4RedToBlack',
+        label: '红到黑圆点',
+        count: 4
+    },
+    {
+        name: '4Rating',
+        label: '四级评分',
+        count: 4
+    },
+    {
+        name: '4TrafficLights',
+        label: '四色交通灯',
+        count: 4
+    },
+    {
+        name: '5Arrows',
+        label: '五向彩色箭头',
+        count: 5
+    },
+    {
+        name: '5ArrowsGray',
+        label: '五向灰色箭头',
+        count: 5
+    },
+    {
+        name: '5Rating',
+        label: '五级评分',
+        count: 5
+    },
+    {
+        name: '5Quarters',
+        label: '五级圆饼',
+        count: 5
+    }
+];
+const COLOR_3 = [
+    '#c62828',
+    '#f9a825',
+    '#2e7d32'
+];
+const COLOR_4 = [
+    '#c62828',
+    '#ef6c00',
+    '#7cb342',
+    '#2e7d32'
+];
+const COLOR_5 = [
+    '#c62828',
+    '#ef6c00',
+    '#f9a825',
+    '#7cb342',
+    '#2e7d32'
+];
+function isSpreadsheetConditionalIconSetName(value) {
+    return SPREADSHEET_CONDITIONAL_ICON_SETS.some((item)=>item.name === value);
+}
+function spreadsheetConditionalIconSetCount(iconSet) {
+    return SPREADSHEET_CONDITIONAL_ICON_SETS.find((item)=>item.name === iconSet).count;
+}
+function defaultSpreadsheetConditionalIconThresholds(iconSet) {
+    const count = spreadsheetConditionalIconSetCount(iconSet);
+    return Array.from({
+        length: count
+    }, (_, index)=>0 === index ? {
+            type: 'min',
+            gte: true
+        } : {
+            type: 'percent',
+            value: Math.round(100 * index / count),
+            gte: true
+        });
+}
+function normalizeSpreadsheetConditionalIconSetFormat(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    if (!isSpreadsheetConditionalIconSetName(source.iconSet) || !Array.isArray(source.thresholds)) return null;
+    const count = spreadsheetConditionalIconSetCount(source.iconSet);
+    if (source.thresholds.length !== count) return null;
+    const thresholds = source.thresholds.map(normalizeThreshold);
+    if (thresholds.some((threshold)=>!threshold)) return null;
+    return {
+        iconSet: source.iconSet,
+        showValue: false !== source.showValue,
+        reverse: true === source.reverse,
+        percent: false !== source.percent,
+        thresholds: thresholds
+    };
+}
+function spreadsheetConditionalIconForValue(sourceFormat, value, sourceValues) {
+    const format = normalizeSpreadsheetConditionalIconSetFormat(sourceFormat);
+    const values = sourceValues.filter(Number.isFinite);
+    if (!format || !Number.isFinite(value) || !values.length) return null;
+    const count = spreadsheetConditionalIconSetCount(format.iconSet);
+    let level = 0;
+    for(let index = 1; index < count; index += 1){
+        const threshold = format.thresholds[index];
+        const cutoff = spreadsheetConditionalThresholdValue(threshold, values);
+        if (null === cutoff) return null;
+        if (threshold.gte ? value >= cutoff : value > cutoff) level = index;
+    }
+    return {
+        iconSet: format.iconSet,
+        index: format.reverse ? count - 1 - level : level,
+        count,
+        showValue: format.showValue
+    };
+}
+function spreadsheetConditionalIconAppearance(icon) {
+    const index = Math.max(0, Math.min(icon.count - 1, icon.index));
+    const definition = SPREADSHEET_CONDITIONAL_ICON_SETS.find((item)=>item.name === icon.iconSet);
+    const label = `${definition.label} ${index + 1}/${icon.count}`;
+    if (icon.iconSet.includes('Arrows')) {
+        const glyphs = 3 === icon.count ? [
+            '↓',
+            '→',
+            '↑'
+        ] : 4 === icon.count ? [
+            '↓',
+            '↘',
+            '↗',
+            '↑'
+        ] : [
+            '↓',
+            '↘',
+            '→',
+            '↗',
+            '↑'
+        ];
+        return {
+            glyph: glyphs[index],
+            color: icon.iconSet.includes('Gray') ? '#606a78' : palette(icon.count)[index],
+            label
+        };
+    }
+    if ('3Flags' === icon.iconSet) return {
+        glyph: '⚑',
+        color: COLOR_3[index],
+        label
+    };
+    if (icon.iconSet.includes('TrafficLights')) return {
+        glyph: '3TrafficLights2' === icon.iconSet ? '◉' : '●',
+        color: palette(icon.count)[index],
+        label
+    };
+    if ('3Signs' === icon.iconSet) return {
+        glyph: [
+            '◆',
+            '▲',
+            '●'
+        ][index],
+        color: COLOR_3[index],
+        label
+    };
+    if ('3Symbols' === icon.iconSet || '3Symbols2' === icon.iconSet) return {
+        glyph: [
+            '✕',
+            '!',
+            '✓'
+        ][index],
+        color: COLOR_3[index],
+        label
+    };
+    if ('4RedToBlack' === icon.iconSet) return {
+        glyph: '●',
+        color: [
+            '#c62828',
+            '#e45b4f',
+            '#697386',
+            '#111827'
+        ][index],
+        label
+    };
+    if ('4Rating' === icon.iconSet) return {
+        glyph: [
+            '▁',
+            '▃',
+            '▆',
+            '█'
+        ][index],
+        color: '#54708f',
+        label
+    };
+    if ('5Rating' === icon.iconSet) return {
+        glyph: [
+            '▁',
+            '▂',
+            '▄',
+            '▆',
+            '█'
+        ][index],
+        color: '#54708f',
+        label
+    };
+    return {
+        glyph: [
+            '○',
+            '◔',
+            '◑',
+            '◕',
+            '●'
+        ][index],
+        color: '#54708f',
+        label
+    };
+}
+function drawSpreadsheetConditionalIcon(context, bounds, icon, background, maskValue = !icon.showValue) {
+    const width = bounds.endX - bounds.startX;
+    const height = bounds.endY - bounds.startY;
+    if (width < 6 || height < 6) return;
+    const appearance = spreadsheetConditionalIconAppearance(icon);
+    context.save();
+    context.beginPath();
+    context.rect(bounds.startX + 1, bounds.startY + 1, Math.max(0, width - 3), Math.max(0, height - 3));
+    context.clip();
+    if (maskValue) {
+        context.fillStyle = background;
+        context.fillRect(bounds.startX + 1, bounds.startY + 1, Math.max(0, width - 3), Math.max(0, height - 3));
+    }
+    const size = Math.max(9, Math.min(16, height - 5));
+    context.fillStyle = appearance.color;
+    context.font = `700 ${size}px "Arial Unicode MS", "Segoe UI Symbol", sans-serif`;
+    context.textAlign = 'left';
+    context.textBaseline = 'middle';
+    context.fillText(appearance.glyph, bounds.startX + 4, bounds.startY + height / 2);
+    context.restore();
+}
+function normalizeThreshold(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    const threshold = normalizeSpreadsheetConditionalThreshold(source);
+    return threshold ? {
+        ...threshold,
+        gte: false !== source.gte
+    } : null;
+}
+function palette(count) {
+    if (3 === count) return COLOR_3;
+    if (4 === count) return COLOR_4;
+    return COLOR_5;
+}
+function effectiveSpreadsheetHeaderFooterSections(sections) {
+    return {
+        left: sections?.left ?? '',
+        center: sections?.center ?? '',
+        right: sections?.right ?? ''
+    };
+}
+const DEFAULT_MARGINS = {
+    top: 19.05,
+    right: 17.78,
+    bottom: 19.05,
+    left: 17.78,
+    header: 7.62,
+    footer: 7.62
+};
+const PAPER_DIMENSIONS = {
+    a3: {
+        width: 297,
+        height: 420
+    },
+    a4: {
+        width: 210,
+        height: 297
+    },
+    a5: {
+        width: 148,
+        height: 210
+    },
+    letter: {
+        width: 215.9,
+        height: 279.4
+    },
+    legal: {
+        width: 215.9,
+        height: 355.6
+    },
+    tabloid: {
+        width: 279.4,
+        height: 431.8
+    }
+};
+PAPER_DIMENSIONS.a4.height, DEFAULT_MARGINS.left, DEFAULT_MARGINS.right;
+PAPER_DIMENSIONS.a4.width, DEFAULT_MARGINS.top, DEFAULT_MARGINS.bottom;
+function effectiveSpreadsheetPageSetup(pageSetup) {
+    return {
+        paperSize: normalizeSpreadsheetPaperSize(pageSetup?.paperSize),
+        orientation: pageSetup?.orientation === 'portrait' ? 'portrait' : 'landscape',
+        scale: boundedInteger(pageSetup?.scale, 10, 400, 100),
+        fitToPage: Boolean(pageSetup?.fitToPage),
+        fitToWidth: boundedInteger(pageSetup?.fitToWidth, 0, 32767, 1),
+        fitToHeight: boundedInteger(pageSetup?.fitToHeight, 0, 32767, 0),
+        horizontalCentered: Boolean(pageSetup?.horizontalCentered),
+        verticalCentered: Boolean(pageSetup?.verticalCentered),
+        header: effectiveSpreadsheetHeaderFooterSections(pageSetup?.header),
+        footer: effectiveSpreadsheetHeaderFooterSections(pageSetup?.footer),
+        pageNumberStart: boundedInteger(pageSetup?.pageNumberStart, 1, 32767, 1),
+        pageOrder: pageSetup?.pageOrder === 'downThenOver' ? 'downThenOver' : 'overThenDown',
+        scaleWithDocument: pageSetup?.scaleWithDocument !== false,
+        alignWithMargins: pageSetup?.alignWithMargins !== false,
+        margins: {
+            top: boundedNumber(pageSetup?.margins?.top, 0, 100, DEFAULT_MARGINS.top),
+            right: boundedNumber(pageSetup?.margins?.right, 0, 100, DEFAULT_MARGINS.right),
+            bottom: boundedNumber(pageSetup?.margins?.bottom, 0, 100, DEFAULT_MARGINS.bottom),
+            left: boundedNumber(pageSetup?.margins?.left, 0, 100, DEFAULT_MARGINS.left),
+            header: boundedNumber(pageSetup?.margins?.header, 0, 100, DEFAULT_MARGINS.header),
+            footer: boundedNumber(pageSetup?.margins?.footer, 0, 100, DEFAULT_MARGINS.footer)
+        }
+    };
+}
+function normalizeSpreadsheetPaperSize(value) {
+    switch(value){
+        case 'a3':
+        case 'a4':
+        case 'a5':
+        case 'letter':
+        case 'legal':
+        case 'tabloid':
+            return value;
+        default:
+            return 'a4';
+    }
+}
+function boundedInteger(value, minimum, maximum, fallback) {
+    return Math.trunc(boundedNumber(value, minimum, maximum, fallback));
+}
+function boundedNumber(value, minimum, maximum, fallback) {
+    return 'number' == typeof value && Number.isFinite(value) && value >= minimum && value <= maximum ? value : fallback;
+}
+export { DEFAULT_PROTECTION_HINT, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, SPREADSHEET_CONDITIONAL_ICON_SETS, applyPasswordlessEditableRanges, applySpreadsheetCellProtectionRanges, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, defaultSpreadsheetColorScaleThresholds, defaultSpreadsheetConditionalIconThresholds, defaultSpreadsheetDataBarOptions, drawSpreadsheetConditionalIcon, editableRangeCellCount, editableRangeRequiresCredentials, effectiveSpreadsheetPageSetup, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isSpreadsheetConditionalComparisonOperator, isSpreadsheetConditionalIconSetName, normalizeSheetProtectionAuthority, normalizeSpreadsheetConditionalIconSetFormat, normalizeSpreadsheetConditionalVisualOptions, normalizeSpreadsheetPaperSize, protectedSheetCount, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sheetHasProtectionState, sheetProtectionAuthority, spreadsheetConditionalComparisonNeedsUpperValue, spreadsheetConditionalIconForValue, spreadsheetConditionalIconSetCount, spreadsheetConditionalThresholdValue, spreadsheetConditionalThresholdsEqual, spreadsheetProtectionKey, unlockedCellCount, withEditableRange, withSheetProtection, withSheetSelectionPermissions, withoutEditableRange };