@a3s-lab/office 0.15.0 → 0.17.0

package/dist/2180.js

@@ -1,11 +1,78 @@
+import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
 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 { sparseMatrixColumnCount, cloneSparseMatrix, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, sparseArrayIndexes, formatSpreadsheetCellRanges, parseSpreadsheetCellRanges as work_spreadsheet_ranges_parseSpreadsheetCellRanges } from "./8715.js";
+import { sparseMatrixColumnCount, cloneSparseMatrix, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, formatSpreadsheetCellRanges, isValidSpreadsheetDefinedName, parseSpreadsheetCellRanges as work_spreadsheet_ranges_parseSpreadsheetCellRanges, sparseArrayIndexes } from "./8715.js";
 import { patchWorkOfficeCollaborationFlatJsonMap, readWorkOfficeCollaborationFlatJsonMap } from "./7060.js";
 import * as __rspack_external_yjs from "yjs";
+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 invalidWorkOfficeSpreadsheetInput(expected) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `Spreadsheet collaboration requires ${expected}.`);
+}
 const MAX_POPULATED_CELLS = 1000000;
 const MAX_DENSE_MATRIX_CELLS = 1000000;
+const MAX_FILTER_VALUES_PER_COLUMN = 10000;
+const MAX_FILTER_VALUE_CHARACTERS = 32767;
+const MAX_FILTER_TEXT_BYTES = 1048576;
+const FILTER_TEXT_ENCODER = new TextEncoder();
+const SPREADSHEET_DYNAMIC_FILTERS = new Set([
+    'above-average',
+    'below-average',
+    'tomorrow',
+    'today',
+    'yesterday',
+    'next-week',
+    'this-week',
+    'last-week',
+    'next-month',
+    'this-month',
+    'last-month',
+    'next-quarter',
+    'this-quarter',
+    'last-quarter',
+    'next-year',
+    'this-year',
+    'last-year',
+    'year-to-date',
+    'quarter-1',
+    'quarter-2',
+    'quarter-3',
+    'quarter-4',
+    'month-1',
+    'month-2',
+    'month-3',
+    'month-4',
+    'month-5',
+    'month-6',
+    'month-7',
+    'month-8',
+    'month-9',
+    'month-10',
+    'month-11',
+    'month-12'
+]);
 const TRANSIENT_SHEET_FIELDS = [
     'calcChain',
     'dynamicArray_compute',
@@ -74,6 +141,7 @@ function validateSheet(value) {
     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.tables) result.tables = validateSpreadsheetTables(source.tables, result.id);
     if (void 0 !== source.formulaMetadata) result.formulaMetadata = validateJsonRecord(requiredInputRecord(source.formulaMetadata, 'formula metadata'), `formula metadata in sheet '${result.id}'`);
     return result;
 }
@@ -128,6 +196,262 @@ function validateIdRecords(value, label) {
         return result;
     });
 }
+function validateSpreadsheetTables(value, sheetId) {
+    const records = validateIdRecords(value, `table in sheet '${sheetId}'`);
+    return records.map((record)=>{
+        const label = `table '${record.id}' in sheet '${sheetId}'`;
+        const range = requiredSpreadsheetTableRange(record.range, label, sheetId);
+        const width = range.column[1] - range.column[0] + 1;
+        const columns = requiredSpreadsheetTableColumns(record.columns, width, label);
+        const filters = requiredSpreadsheetTableFilters(record.filters, width, label);
+        const headerRow = requiredBoolean(record.headerRow, `${label} header row`);
+        const totalsRow = requiredBoolean(record.totalsRow, `${label} totals row`);
+        const height = range.row[1] - range.row[0] + 1;
+        if (height <= Number(headerRow) + Number(totalsRow)) invalidWorkOfficeSpreadsheetInput(`${label} to include at least one body row`);
+        const result = record;
+        result.name = requiredSpreadsheetTableName(record.name, `${label} name`);
+        if (void 0 !== record.displayName) result.displayName = requiredSpreadsheetTableName(record.displayName, `${label} display name`);
+        if (void 0 !== record.ooxmlId) {
+            if (!Number.isSafeInteger(record.ooxmlId) || Number(record.ooxmlId) < 1) invalidWorkOfficeSpreadsheetInput(`a positive OOXML ID for ${label}`);
+            result.ooxmlId = Number(record.ooxmlId);
+        }
+        result.range = range;
+        result.columns = columns;
+        result.filters = filters;
+        result.headerRow = headerRow;
+        result.totalsRow = totalsRow;
+        const style = requiredSpreadsheetTableStyle(record.style, label);
+        const showFirstColumn = requiredBoolean(record.showFirstColumn, `${label} first-column emphasis`);
+        const showLastColumn = requiredBoolean(record.showLastColumn, `${label} last-column emphasis`);
+        const showRowStripes = requiredBoolean(record.showRowStripes, `${label} row stripes`);
+        const showColumnStripes = requiredBoolean(record.showColumnStripes, `${label} column stripes`);
+        if (!headerRow && filters.length > 0) invalidWorkOfficeSpreadsheetInput(`${label} filters to require an enabled header row`);
+        if ('none' === style.family && (showFirstColumn || showLastColumn || showRowStripes || showColumnStripes)) invalidWorkOfficeSpreadsheetInput(`${label} style flags to require a built-in style`);
+        result.style = style;
+        result.showFirstColumn = showFirstColumn;
+        result.showLastColumn = showLastColumn;
+        result.showRowStripes = showRowStripes;
+        result.showColumnStripes = showColumnStripes;
+        return result;
+    });
+}
+function requiredSpreadsheetTableRange(value, label, sheetId) {
+    const record = requiredInputRecord(value, `${label} range`);
+    const readAxis = (candidate, maximum, axis)=>{
+        if (!Array.isArray(candidate) || 2 !== candidate.length) invalidWorkOfficeSpreadsheetInput(`a bounded ${axis} range for ${label}`);
+        const start = requiredCoordinate(candidate[0], maximum, `${axis} start`, sheetId);
+        const end = requiredCoordinate(candidate[1], maximum, `${axis} end`, sheetId);
+        if (start > end) invalidWorkOfficeSpreadsheetInput(`an ordered ${axis} range for ${label}`);
+        return [
+            start,
+            end
+        ];
+    };
+    return {
+        row: readAxis(record.row, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, 'row'),
+        column: readAxis(record.column, 16384, 'column')
+    };
+}
+function requiredSpreadsheetTableColumns(value, width, label) {
+    if (!Array.isArray(value) || value.length !== width) invalidWorkOfficeSpreadsheetInput(`${label} to have one column definition per worksheet column`);
+    const names = new Set();
+    return value.map((candidate)=>{
+        const record = requiredInputRecord(candidate, `${label} column`);
+        assertExactRecordKeys(record, [
+            'name'
+        ], `column for ${label}`);
+        const name = requiredTableColumnName(record.name, label);
+        const normalized = name.toLocaleLowerCase();
+        if (names.has(normalized)) invalidWorkOfficeSpreadsheetInput(`unique column names for ${label}`);
+        names.add(normalized);
+        return {
+            name
+        };
+    });
+}
+function requiredSpreadsheetTableFilters(value, width, label) {
+    if (!Array.isArray(value)) invalidWorkOfficeSpreadsheetInput(`an array of filters for ${label}`);
+    const columns = new Set();
+    const textBudget = {
+        bytes: 0
+    };
+    return value.map((candidate)=>{
+        const record = validateJsonRecord(requiredInputRecord(candidate, `${label} filter`), `${label} filter`);
+        assertExactRecordKeys(record, [
+            'column',
+            'criteria'
+        ], `filter for ${label}`);
+        if (!Number.isSafeInteger(record.column) || Number(record.column) < 0 || Number(record.column) >= width || columns.has(Number(record.column))) invalidWorkOfficeSpreadsheetInput(`unique in-range filter columns for ${label}`);
+        const column = Number(record.column);
+        const criteria = requiredSpreadsheetTableFilterCriteria(record.criteria, label, textBudget);
+        columns.add(column);
+        return {
+            column,
+            criteria
+        };
+    });
+}
+function requiredSpreadsheetTableFilterCriteria(value, label, textBudget) {
+    const record = validateJsonRecord(requiredInputRecord(value, `filter criteria for ${label}`), `filter criteria for ${label}`);
+    const type = record.type;
+    switch(type){
+        case 'values':
+            {
+                assertExactRecordKeys(record, [
+                    'type',
+                    'values',
+                    'includeBlanks'
+                ], `filter criteria for ${label}`);
+                if (!Array.isArray(record.values) || record.values.length > MAX_FILTER_VALUES_PER_COLUMN) invalidWorkOfficeSpreadsheetInput(`at most ${MAX_FILTER_VALUES_PER_COLUMN.toLocaleString()} values in filter criteria for ${label}`);
+                const includeBlanks = requiredBoolean(record.includeBlanks, `filter blank inclusion for ${label}`);
+                if (0 === record.values.length && !includeBlanks) invalidWorkOfficeSpreadsheetInput(`at least one value or includeBlanks=true in filter criteria for ${label}`);
+                const observed = new Set();
+                const values = [];
+                for (const candidate of record.values){
+                    const filterValue = requiredSpreadsheetFilterText(candidate, label, textBudget);
+                    if (observed.has(filterValue)) invalidWorkOfficeSpreadsheetInput(`unique filter values in criteria for ${label}`);
+                    observed.add(filterValue);
+                    values.push(filterValue);
+                }
+                return {
+                    type,
+                    values,
+                    includeBlanks
+                };
+            }
+        case 'equals':
+        case 'not-equals':
+        case 'contains':
+        case 'does-not-contain':
+        case 'begins-with':
+        case 'ends-with':
+        case 'greater-than':
+        case 'greater-than-or-equal':
+        case 'less-than':
+        case 'less-than-or-equal':
+            assertExactRecordKeys(record, [
+                'type',
+                'value'
+            ], `filter criteria for ${label}`);
+            return {
+                type,
+                value: requiredSpreadsheetFilterText(record.value, label, textBudget)
+            };
+        case 'between':
+        case 'not-between':
+            assertExactRecordKeys(record, [
+                'type',
+                'lower',
+                'upper'
+            ], `filter criteria for ${label}`);
+            return {
+                type,
+                lower: requiredSpreadsheetFilterText(record.lower, label, textBudget),
+                upper: requiredSpreadsheetFilterText(record.upper, label, textBudget)
+            };
+        case 'blanks':
+        case 'non-blanks':
+            assertExactRecordKeys(record, [
+                'type'
+            ], `filter criteria for ${label}`);
+            return {
+                type
+            };
+        case 'top':
+        case 'bottom':
+            assertExactRecordKeys(record, [
+                'type',
+                'count'
+            ], `filter criteria for ${label}`);
+            return {
+                type,
+                count: requiredSpreadsheetFilterInteger(record.count, 1, 500, `a ${type} filter count from 1 through 500 for ${label}`)
+            };
+        case 'top-percent':
+        case 'bottom-percent':
+            assertExactRecordKeys(record, [
+                'type',
+                'percent'
+            ], `filter criteria for ${label}`);
+            return {
+                type,
+                percent: requiredSpreadsheetFilterInteger(record.percent, 1, 100, `a ${type} filter percentage from 1 through 100 for ${label}`)
+            };
+        case 'dynamic':
+            assertExactRecordKeys(record, [
+                'type',
+                'kind'
+            ], `filter criteria for ${label}`);
+            if ('string' != typeof record.kind || !SPREADSHEET_DYNAMIC_FILTERS.has(record.kind)) invalidWorkOfficeSpreadsheetInput(`a supported dynamic filter for ${label}`);
+            return {
+                type,
+                kind: record.kind
+            };
+        default:
+            invalidWorkOfficeSpreadsheetInput(`supported filter criteria for ${label}`);
+    }
+}
+function requiredSpreadsheetFilterText(value, label, textBudget) {
+    if ('string' != typeof value) invalidWorkOfficeSpreadsheetInput(`filter text containing 1 to ${MAX_FILTER_VALUE_CHARACTERS.toLocaleString()} characters for ${label}`);
+    let characters = 0;
+    for (const character of value){
+        characters += 1;
+        const codePoint = character.codePointAt(0);
+        if (void 0 === codePoint || !(0x9 === codePoint || 0xa === codePoint || 0xd === codePoint || codePoint >= 0x20 && codePoint <= 0xd7ff || codePoint >= 0xe000 && codePoint <= 0xfffd || codePoint >= 0x10000 && codePoint <= 0x10ffff)) invalidWorkOfficeSpreadsheetInput(`XML-compatible filter text for ${label}`);
+    }
+    if (characters < 1 || characters > MAX_FILTER_VALUE_CHARACTERS) invalidWorkOfficeSpreadsheetInput(`filter text containing 1 to ${MAX_FILTER_VALUE_CHARACTERS.toLocaleString()} characters for ${label}`);
+    textBudget.bytes += FILTER_TEXT_ENCODER.encode(value).byteLength;
+    if (textBudget.bytes > MAX_FILTER_TEXT_BYTES) invalidWorkOfficeSpreadsheetInput(`filter text totaling at most ${MAX_FILTER_TEXT_BYTES.toLocaleString()} bytes for ${label}`);
+    return value;
+}
+function requiredSpreadsheetFilterInteger(value, minimum, maximum, expected) {
+    if (!Number.isSafeInteger(value) || Number(value) < minimum || Number(value) > maximum) invalidWorkOfficeSpreadsheetInput(expected);
+    return Number(value);
+}
+function assertExactRecordKeys(record, keys, label) {
+    const allowed = new Set(keys);
+    if (keys.some((key)=>!Object.hasOwn(record, key)) || Object.keys(record).some((key)=>!allowed.has(key))) invalidWorkOfficeSpreadsheetInput(`a complete ${label} record without unknown fields`);
+}
+function requiredSpreadsheetTableStyle(value, label) {
+    const record = validateJsonRecord(requiredInputRecord(value, `${label} style`), `${label} style`);
+    const family = record.family;
+    if ('none' === family) {
+        assertExactRecordKeys(record, [
+            'family'
+        ], `style for ${label}`);
+        return {
+            family
+        };
+    }
+    assertExactRecordKeys(record, [
+        'family',
+        'number'
+    ], `style for ${label}`);
+    const maximum = 'light' === family ? 21 : 'medium' === family ? 28 : 11;
+    if ('light' !== family && 'medium' !== family && 'dark' !== family || !Number.isSafeInteger(record.number) || Number(record.number) < 1 || Number(record.number) > maximum) invalidWorkOfficeSpreadsheetInput(`a built-in table style for ${label}`);
+    return {
+        family,
+        number: Number(record.number)
+    };
+}
+function requiredSpreadsheetTableName(value, label) {
+    if ('string' != typeof value || value.trim() !== value || Array.from(value).length < 1 || Array.from(value).length > 255) invalidWorkOfficeSpreadsheetInput(`a valid table name for ${label}`);
+    const result = value;
+    if (!isValidSpreadsheetDefinedName(result) || [
+        'r',
+        'c'
+    ].includes(result.toLocaleLowerCase())) invalidWorkOfficeSpreadsheetInput(`a valid table name for ${label}`);
+    return result;
+}
+function requiredTableColumnName(value, label) {
+    const characters = 'string' == typeof value ? Array.from(value) : [];
+    if ('string' != typeof value || characters.length < 1 || characters.length > 255 || value.trim() !== value || characters.some((character)=>/\p{Cc}/u.test(character) || '\uFFFE' === character || '\uFFFF' === character)) invalidWorkOfficeSpreadsheetInput(`a valid column name for ${label}`);
+    return value;
+}
+function requiredBoolean(value, label) {
+    if ('boolean' != typeof value) invalidWorkOfficeSpreadsheetInput(`a Boolean value for ${label}`);
+    return value;
+}
 function copyOptionalSheetSidecars(source, target, key, label) {
     const value = source[key];
     if (void 0 === value) return;
@@ -151,8 +475,25 @@ function copyOptionalJsonField(source, target, key, label) {
 }
 function assertSpreadsheetReferences(content) {
     const sheetIds = new Set(content.sheets.map((sheet)=>sheet.id));
+    const definedNames = new Set((content.namedRanges ?? []).map((range)=>range.name.trim().toLocaleLowerCase()));
+    const tableNames = new Set();
     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 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 [index, table] of (sheet.tables ?? []).entries()){
+            const names = [
+                table.name,
+                table.displayName
+            ].filter((value)=>Boolean(value));
+            for (const name of names){
+                const normalized = name.toLocaleLowerCase();
+                if (definedNames.has(normalized) || tableNames.has(normalized)) invalidWorkOfficeSpreadsheetInput(`unique table and defined names; '${name}' is repeated`);
+                tableNames.add(normalized);
+            }
+            if (table.range.row[1] >= (sheet.row ?? OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) || table.range.column[1] >= (sheet.column ?? 16384)) invalidWorkOfficeSpreadsheetInput(`table '${table.id}' to fit within sheet '${sheet.id}'`);
+            for (const other of (sheet.tables ?? []).slice(0, index))if (spreadsheetTableRangesIntersect(table.range, other.range)) invalidWorkOfficeSpreadsheetInput(`non-overlapping tables in sheet '${sheet.id}'`);
+        }
+    }
     for (const key of [
         'printAreas',
         'printTitles',
@@ -160,42 +501,18 @@ function assertSpreadsheetReferences(content) {
         'pageSetups'
     ])for (const record of content[key] ?? [])if (!sheetIds.has(record.sheetId)) invalidWorkOfficeSpreadsheetInput(`${key} to reference an existing sheet '${record.sheetId}'`);
 }
+function spreadsheetTableRangesIntersect(left, right) {
+    return left.row[0] <= right.row[1] && left.row[1] >= right.row[0] && left.column[0] <= right.column[1] && left.column[1] >= right.column[0];
+}
 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,
@@ -207,6 +524,7 @@ function appendWorkOfficeSpreadsheetRecordClaims(claims, previous, next) {
         appendChildClaims(claims, before, sheet, 'image', 'images');
         appendChildClaims(claims, before, sheet, 'chart', 'charts');
         appendChildClaims(claims, before, sheet, 'pivot-table', 'pivotTables');
+        appendChildClaims(claims, before, sheet, 'table', 'tables');
     }
     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);
@@ -225,6 +543,7 @@ function assertWorkOfficeSpreadsheetRecordClaims(claims, content) {
         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 table of sheet.tables ?? [])assertClaimExists(fingerprints, 'table', table.id, sheet.id);
     }
     for (const range of content.namedRanges ?? [])assertClaimExists(fingerprints, 'named-range', range.id);
 }
@@ -275,7 +594,7 @@ function parsedClaim(raw) {
     };
 }
 function requiredClaimKind(value) {
-    if ('chart' === value || 'image' === value || 'named-range' === value || 'pivot-table' === value || 'sheet' === value) return value;
+    if ('chart' === value || 'image' === value || 'named-range' === value || 'pivot-table' === value || 'table' === value || 'sheet' === value) return value;
     invalidWorkOfficeSpreadsheetShared('record claim kind');
 }
 function requiredClaimIdentifier(value, label) {
@@ -304,6 +623,7 @@ function claimIdentity(kind, id, parentId) {
 function claimLabel(claim) {
     if ('named-range' === claim.kind) return 'named range';
     if ('pivot-table' === claim.kind) return `pivot table in sheet '${claim.parentId}'`;
+    if ('table' === claim.kind) return `table in sheet '${claim.parentId}'`;
     if ('sheet' === claim.kind) return 'sheet';
     return `${claim.kind} in sheet '${claim.parentId}'`;
 }
@@ -327,7 +647,8 @@ function assertCompatibleSheet(previous, next, shared, label) {
         'formulaMetadata',
         'images',
         'charts',
-        'pivotTables'
+        'pivotTables',
+        'tables'
     ]);
     assertCompatibleValue(withoutKeys(previous, omitted), withoutKeys(next, omitted), withoutKeys(shared, omitted), label);
     assertCompatibleValue(previous.config, next.config, shared.config, `${label} config`);
@@ -335,6 +656,7 @@ function assertCompatibleSheet(previous, next, shared, label) {
     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`);
+    assertRecordCollection(previous.tables ?? [], next.tables ?? [], shared.tables ?? [], (table)=>table.id, `${label} table`);
     assertCellCollection(spreadsheetCells(previous), spreadsheetCells(next), spreadsheetCells(shared), label);
 }
 function assertCellCollection(previous, next, shared, sheetLabel) {
@@ -700,6 +1022,8 @@ const SPREADSHEET_RECORD_CHARTS = 'charts';
 const SPREADSHEET_RECORD_CHART_ORDER = 'chartOrder';
 const SPREADSHEET_RECORD_PIVOTS = 'pivotTables';
 const SPREADSHEET_RECORD_PIVOT_ORDER = 'pivotOrder';
+const SPREADSHEET_RECORD_TABLES = 'tables';
+const SPREADSHEET_RECORD_TABLE_ORDER = 'tableOrder';
 const NESTED_SHEET_FIELDS = new Set([
     "cells",
     SPREADSHEET_RECORD_CELL_PRESENCE,
@@ -712,7 +1036,9 @@ const NESTED_SHEET_FIELDS = new Set([
     SPREADSHEET_RECORD_CHARTS,
     SPREADSHEET_RECORD_CHART_ORDER,
     SPREADSHEET_RECORD_PIVOTS,
-    SPREADSHEET_RECORD_PIVOT_ORDER
+    SPREADSHEET_RECORD_PIVOT_ORDER,
+    SPREADSHEET_RECORD_TABLES,
+    SPREADSHEET_RECORD_TABLE_ORDER
 ]);
 function initializeSpreadsheetSheetRecord(record, sheet) {
     office_spreadsheet_collaboration_records_nestedSpreadsheetMap(record, SPREADSHEET_RECORD_CONFIG, 'sheet config');
@@ -720,6 +1046,7 @@ function initializeSpreadsheetSheetRecord(record, sheet) {
     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);
+    initializeIdCollection(record, SPREADSHEET_RECORD_TABLES, SPREADSHEET_RECORD_TABLE_ORDER);
     patchSpreadsheetSheetRecord(record, void 0, sheet);
 }
 function patchSpreadsheetSheetRecord(record, previous, next) {
@@ -729,13 +1056,14 @@ function patchSpreadsheetSheetRecord(record, previous, next) {
         ...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);
+    for (const key of keys)if ('data' !== key && 'celldata' !== key && 'config' !== key && 'formulaMetadata' !== key && 'images' !== key && 'charts' !== key && 'pivotTables' !== key && 'tables' !== 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}'`);
+    patchIdCollection(record, SPREADSHEET_RECORD_TABLES, SPREADSHEET_RECORD_TABLE_ORDER, previous?.tables ?? [], next.tables ?? [], `table in sheet '${next.id}'`);
 }
 function readSpreadsheetSheetRecord(record, id) {
     const result = {};
@@ -753,6 +1081,7 @@ function readSpreadsheetSheetRecord(record, id) {
     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);
+    readBackwardCompatibleCollection(record, SPREADSHEET_RECORD_TABLES, SPREADSHEET_RECORD_TABLE_ORDER, `table in sheet '${id}'`, 'tables', result);
     return sheet;
 }
 function patchSpreadsheetOrder(order, previous, next) {
@@ -843,6 +1172,13 @@ function readOptionalCollection(parent, recordsKey, orderKey, label, outputKey,
     });
     if (result.length > 0) output[outputKey] = result;
 }
+function readBackwardCompatibleCollection(parent, recordsKey, orderKey, label, outputKey, output) {
+    const hasRecords = parent.has(recordsKey);
+    const hasOrder = parent.has(orderKey);
+    if (!hasRecords && !hasOrder) return;
+    if (hasRecords !== hasOrder) invalidWorkOfficeSpreadsheetShared(label);
+    readOptionalCollection(parent, recordsKey, orderKey, label, outputKey, output);
+}
 function patchJsonMap(target, previous, next) {
     patchSpreadsheetFlatJsonMap(target, previous, next, 'Spreadsheet record');
 }