@a3s-lab/office 0.35.0 → 0.37.0

package/dist/office-kernel.worker.js

@@ -13727,6 +13727,13 @@
                     1
                 ]
             ],
+            [
+                'SUBTOTAL',
+                [
+                    2,
+                    255
+                ]
+            ],
             [
                 'SUM',
                 [
@@ -13747,6 +13754,90 @@
             while(normalized.startsWith('_XLFN.') || normalized.startsWith('_XLWS.'))normalized = normalized.slice(6);
             return normalized;
         }
+        function evaluateParserSubtotal(parameters) {
+            const codeValue = parserNumericValue(parameters[0]);
+            if (void 0 === codeValue) return 'VALUE!';
+            const code = Math.trunc(codeValue);
+            const values = parameters.slice(1).flatMap((parameter)=>flattenParserValues(parameter));
+            for (const value of values){
+                const error = parserErrorValue(value);
+                if (error) return error;
+            }
+            switch(code){
+                case 1:
+                case 101:
+                    return parserSubtotalNumeric(values, 'average');
+                case 2:
+                case 102:
+                    return values.filter((value)=>'number' == typeof value).length;
+                case 3:
+                case 103:
+                    return values.filter((value)=>null != value).length;
+                case 4:
+                case 104:
+                    return parserSubtotalNumeric(values, 'max');
+                case 5:
+                case 105:
+                    return parserSubtotalNumeric(values, 'min');
+                case 6:
+                case 106:
+                    return parserSubtotalNumeric(values, 'product');
+                case 7:
+                case 107:
+                    return parserSubtotalNumeric(values, 'stddev');
+                case 8:
+                case 108:
+                    return parserSubtotalNumeric(values, 'stddevp');
+                case 9:
+                case 109:
+                    return parserSubtotalNumeric(values, 'sum');
+                case 10:
+                case 110:
+                    return parserSubtotalNumeric(values, 'var');
+                case 11:
+                case 111:
+                    return parserSubtotalNumeric(values, 'varp');
+                default:
+                    return 'VALUE!';
+            }
+        }
+        function parserSubtotalNumeric(values, operation) {
+            const numbers = values.filter((value)=>'number' == typeof value && Number.isFinite(value));
+            const count = numbers.length;
+            const sum = numbers.reduce((total, value)=>total + value, 0);
+            if ('sum' === operation) return finiteParserNumber(sum);
+            if ('average' === operation) return count ? finiteParserNumber(sum / count) : 'DIV/0!';
+            if ('max' === operation) return finiteParserNumber(Math.max(...numbers, 0));
+            if ('min' === operation) return finiteParserNumber(Math.min(...numbers, 0));
+            if ('product' === operation) return finiteParserNumber(count ? numbers.reduce((total, value)=>total * value, 1) : 0);
+            if ('stddev' === operation || 'var' === operation) {
+                if (count < 2) return 'DIV/0!';
+            } else if (0 === count) return 'DIV/0!';
+            const mean = sum / count;
+            const divisor = 'stddev' === operation || 'var' === operation ? count - 1 : count;
+            const variance = numbers.reduce((total, value)=>total + (value - mean) ** 2, 0) / divisor;
+            return finiteParserNumber('stddev' === operation || 'stddevp' === operation ? Math.sqrt(variance) : variance);
+        }
+        function flattenParserValues(value) {
+            if (!Array.isArray(value)) return [
+                value
+            ];
+            return value.flatMap((entry)=>flattenParserValues(entry));
+        }
+        function parserNumericValue(value) {
+            if ('number' == typeof value) return Number.isFinite(value) ? value : void 0;
+            if ('boolean' == typeof value) return value ? 1 : 0;
+            if ('string' != typeof value || !value.trim()) return;
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : void 0;
+        }
+        function parserErrorValue(value) {
+            if (value instanceof Error) return value.message.startsWith('#') ? value.message.slice(1) : 'VALUE!';
+            return 'string' == typeof value && value.startsWith('#') ? value.slice(1) : void 0;
+        }
+        function finiteParserNumber(value) {
+            return Number.isFinite(value) ? value : 'NUM!';
+        }
         function normalizeFormulaForFortuneParser(formula) {
             const source = formula.replace(/^=/, '');
             let output = '';
@@ -13916,6 +14007,7 @@
                 if (!sheet.id.trim() || utf8ByteLength(sheet.id) > MAX_SPREADSHEET_IDENTIFIER_BYTES || !sheet.name.trim() || utf8ByteLength(sheet.name) > MAX_SPREADSHEET_IDENTIFIER_BYTES || sheetIds.has(sheet.id) || sheetNames.has(normalizedName)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.sheet_invalid', 'Spreadsheet sheet IDs and names must be unique and non-empty.');
                 sheetIds.add(sheet.id);
                 sheetNames.add(normalizedName);
+                validateSpreadsheetTables(sheet, request.sheets);
                 const coordinates = new Set();
                 for (const cell of sheet.cells){
                     const key = `${cell.row}:${cell.column}`;
@@ -13927,6 +14019,68 @@
             }
             for (const target of request.targets ?? [])if (!sheetIds.has(target.sheetId) || !boundedSpreadsheetIndex(target.row, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) || !boundedSpreadsheetIndex(target.column, 16384)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.target_invalid', 'Spreadsheet calculation targets must reference an existing, bounded cell.');
         }
+        function validateSpreadsheetTables(sheet, sheets) {
+            const tables = sheet.tables ?? [];
+            const tableCount = sheets.reduce((count, candidate)=>count + (candidate.tables?.length ?? 0), 0);
+            if (tableCount > 1024) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_limit_exceeded', 'A Spreadsheet calculation request may contain at most 1024 tables.');
+            const aliases = new Map();
+            for (const candidate of sheets)for (const [tableIndex, table] of (candidate.tables ?? []).entries()){
+                const identity = `${candidate.id}\u0000${tableIndex}`;
+                for (const alias of [
+                    table.name,
+                    table.displayName
+                ]){
+                    if (!alias) continue;
+                    const normalized = alias.toLocaleLowerCase();
+                    const existing = aliases.get(normalized);
+                    if (existing && existing !== identity) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_invalid', `Spreadsheet table name '${alias}' is ambiguous.`);
+                    aliases.set(normalized, identity);
+                }
+            }
+            const ranges = [];
+            for (const table of tables){
+                for (const [kind, value] of [
+                    [
+                        'startRow',
+                        table.startRow
+                    ],
+                    [
+                        'endRow',
+                        table.endRow
+                    ],
+                    [
+                        'startColumn',
+                        table.startColumn
+                    ],
+                    [
+                        'endColumn',
+                        table.endColumn
+                    ]
+                ])if (!boundedSpreadsheetIndex(value, kind.endsWith('Row') ? OFFICE_KERNEL_SPREADSHEET_MAX_ROWS : 16384)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_invalid', `Spreadsheet table '${table.name}' has an out-of-bounds ${kind}.`);
+                if (table.startRow > table.endRow || table.startColumn > table.endColumn || table.columns.length !== table.endColumn - table.startColumn + 1) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_invalid', `Spreadsheet table '${table.name}' has an invalid range or column count.`);
+                validateTableName(table.name, 'name');
+                if (void 0 !== table.displayName) validateTableName(table.displayName, 'displayName');
+                const columnNames = new Set();
+                for (const column of table.columns){
+                    validateTableName(column, 'column');
+                    const normalized = column.toLocaleLowerCase();
+                    if (columnNames.has(normalized)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_invalid', `Spreadsheet table '${table.name}' contains duplicate column names.`);
+                    columnNames.add(normalized);
+                }
+                if (table.headerRow && table.totalsRow && table.startRow === table.endRow) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_invalid', `Spreadsheet table '${table.name}' cannot use header and totals rows in one row.`);
+                for (const previous of ranges)if (table.startRow <= previous.endRow && table.endRow >= previous.startRow && table.startColumn <= previous.endColumn && table.endColumn >= previous.startColumn) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_invalid', `Spreadsheet tables '${previous.name}' and '${table.name}' overlap.`);
+                ranges.push({
+                    startRow: table.startRow,
+                    endRow: table.endRow,
+                    startColumn: table.startColumn,
+                    endColumn: table.endColumn,
+                    name: table.name
+                });
+            }
+        }
+        function validateTableName(value, kind) {
+            if (!value.trim() || utf8ByteLength(value) > MAX_SPREADSHEET_IDENTIFIER_BYTES) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.table_invalid', `Spreadsheet table ${kind} must contain 1-${MAX_SPREADSHEET_IDENTIFIER_BYTES} UTF-8 bytes.`);
+        }
         function boundedSpreadsheetIndex(value, exclusiveMaximum) {
             return Number.isSafeInteger(value) && value >= 0 && value < exclusiveMaximum;
         }
@@ -14020,6 +14174,428 @@
             const withSuffix = '#DIV/0' === normalized ? '#DIV/0!' : normalized;
             return isOfficeKernelSpreadsheetError(withSuffix);
         }
+        class SpreadsheetStructuredReferenceError extends Error {
+            kind;
+            constructor(kind, message){
+                super(message);
+                this.name = 'SpreadsheetStructuredReferenceError';
+                this.kind = kind;
+            }
+        }
+        function parseSpreadsheetStructuredReference(reference) {
+            const open = reference.indexOf('[');
+            if (open < 0) throw invalidReference(reference);
+            const tableName = reference.slice(0, open) || void 0;
+            const content = outerGroup(reference.slice(open));
+            if (null === content) throw invalidReference(reference);
+            const rows = {
+                all: false,
+                headers: false,
+                data: false,
+                totals: false,
+                current: false
+            };
+            let firstColumn;
+            let lastColumn;
+            if (content.startsWith('@')) {
+                rows.current = true;
+                const column = parseCurrentColumn(content.slice(1), reference);
+                firstColumn = column;
+                lastColumn = column;
+            } else if (content.startsWith('[')) [firstColumn, lastColumn] = parseNestedSelection(content, reference, rows);
+            else {
+                const item = tableItem(content);
+                if (item) applyTableItem(rows, item, reference);
+                else {
+                    const column = parsePlainColumn(content, reference);
+                    firstColumn = column;
+                    lastColumn = column;
+                }
+            }
+            if (!rows.all && !rows.headers && !rows.data && !rows.totals && !rows.current) rows.data = true;
+            return {
+                tableName,
+                firstColumn,
+                lastColumn,
+                rows
+            };
+        }
+        class SpreadsheetStructuredReferenceCatalog {
+            sheets;
+            definitions = [];
+            byName = new Map();
+            bySheet = new Map();
+            constructor(sheets){
+                this.sheets = sheets;
+                for (const sheet of sheets){
+                    const indexes = [];
+                    for (const table of sheet.tables ?? []){
+                        const definition = {
+                            ...table,
+                            sheetId: sheet.id,
+                            sheetName: sheet.name
+                        };
+                        const index = this.definitions.length;
+                        this.definitions.push(definition);
+                        indexes.push(index);
+                        for (const alias of [
+                            table.name,
+                            table.displayName
+                        ]){
+                            if (!alias) continue;
+                            const key = alias.toLocaleLowerCase();
+                            if (!this.byName.has(key)) this.byName.set(key, index);
+                        }
+                    }
+                    this.bySheet.set(sheet.id, indexes);
+                }
+            }
+            resolve(qualifier, reference, currentSheet, currentColumn, currentRow) {
+                const parsed = parseSpreadsheetStructuredReference(reference);
+                const table = this.resolveTable(parsed, reference, currentSheet, currentColumn, currentRow);
+                if (qualifier && table.sheetName.toLocaleLowerCase() !== qualifier.toLocaleLowerCase()) throw new SpreadsheetStructuredReferenceError('missing-table', `Spreadsheet table '${table.name}' is not on worksheet '${qualifier}'.`);
+                if (parsed.rows.current && currentSheet.id !== table.sheetId) throw new SpreadsheetStructuredReferenceError('unsupported', `Structured reference #This Row requires the current formula cell to be on table '${table.name}'.`);
+                const [startColumn, endColumn] = this.resolveColumns(table, parsed);
+                return this.resolveRows(table, parsed.rows, currentRow).map(([startRow, endRow])=>({
+                        sheetId: table.sheetId,
+                        sheetName: table.sheetName,
+                        startRow,
+                        endRow,
+                        startColumn,
+                        endColumn
+                    }));
+            }
+            resolveTable(parsed, reference, currentSheet, currentColumn, currentRow) {
+                if (parsed.tableName) {
+                    const index = this.byName.get(parsed.tableName.toLocaleLowerCase());
+                    if (void 0 === index) throw new SpreadsheetStructuredReferenceError('missing-table', `Spreadsheet table '${parsed.tableName}' does not exist.`);
+                    const table = this.definitions[index];
+                    if (!table) throw invalidReference(reference);
+                    return table;
+                }
+                const matching = (this.bySheet.get(currentSheet.id) ?? []).map((index)=>this.definitions[index]).filter((table)=>void 0 !== table && currentRow >= table.startRow && currentRow <= table.endRow && currentColumn >= table.startColumn && currentColumn <= table.endColumn);
+                if (!matching.length) throw new SpreadsheetStructuredReferenceError('missing-table', `Table-local structured reference '${reference}' requires the current formula cell to be inside a Spreadsheet table.`);
+                if (matching.length > 1) throw new SpreadsheetStructuredReferenceError('unsupported', `Table-local structured reference '${reference}' is ambiguous at the current formula cell.`);
+                return matching[0];
+            }
+            resolveColumns(table, parsed) {
+                let first = 0;
+                let last = table.columns.length - 1;
+                if (void 0 !== parsed.firstColumn && void 0 !== parsed.lastColumn) {
+                    first = table.columns.findIndex((column)=>column.toLocaleLowerCase() === parsed.firstColumn.toLocaleLowerCase());
+                    last = table.columns.findIndex((column)=>column.toLocaleLowerCase() === parsed.lastColumn.toLocaleLowerCase());
+                    if (first < 0) throw new SpreadsheetStructuredReferenceError('missing-column', `Spreadsheet table '${table.name}' has no column '${parsed.firstColumn}'.`);
+                    if (last < 0) throw new SpreadsheetStructuredReferenceError('missing-column', `Spreadsheet table '${table.name}' has no column '${parsed.lastColumn}'.`);
+                    if (first > last) throw new SpreadsheetStructuredReferenceError('unsupported', `Structured-reference column range '${parsed.firstColumn}:${parsed.lastColumn}' is reversed.`);
+                }
+                if (first < 0 || last < first || table.startColumn + last > table.endColumn) throw invalidReference(table.name);
+                return [
+                    table.startColumn + first,
+                    table.startColumn + last
+                ];
+            }
+            resolveRows(table, rows, currentRow) {
+                const selected = [];
+                if (rows.all) selected.push([
+                    table.startRow,
+                    table.endRow
+                ]);
+                if (rows.headers) {
+                    if (!table.headerRow) throw missingRows(table, '#Headers');
+                    selected.push([
+                        table.startRow,
+                        table.startRow
+                    ]);
+                }
+                if (rows.data) selected.push(this.dataRows(table));
+                if (rows.totals) {
+                    if (!table.totalsRow) throw missingRows(table, '#Totals');
+                    selected.push([
+                        table.endRow,
+                        table.endRow
+                    ]);
+                }
+                if (rows.current) {
+                    const [start, end] = this.dataRows(table);
+                    if (currentRow < start || currentRow > end) throw new SpreadsheetStructuredReferenceError('unsupported', `Structured reference #This Row requires the current formula row to be inside table '${table.name}'.`);
+                    selected.push([
+                        currentRow,
+                        currentRow
+                    ]);
+                }
+                selected.sort((left, right)=>left[0] - right[0]);
+                const merged = [];
+                for (const [start, end] of selected){
+                    const previous = merged.at(-1);
+                    if (previous && start <= previous[1] + 1) previous[1] = Math.max(previous[1], end);
+                    else merged.push([
+                        start,
+                        end
+                    ]);
+                }
+                if (!merged.length) throw new SpreadsheetStructuredReferenceError('unsupported', 'Structured reference selects no table rows.');
+                return merged;
+            }
+            dataRows(table) {
+                const start = table.startRow + (table.headerRow ? 1 : 0);
+                const end = table.endRow - (table.totalsRow ? 1 : 0);
+                if (start > end) throw new SpreadsheetStructuredReferenceError('unsupported', `Spreadsheet table '${table.name}' has no data rows.`);
+                return [
+                    start,
+                    end
+                ];
+            }
+        }
+        function expandSpreadsheetStructuredReferences(formula, catalog, currentSheet, currentRow, currentColumn) {
+            const hasEquals = formula.startsWith('=');
+            const source = hasEquals ? formula.slice(1) : formula;
+            let output = '';
+            let cursor = 0;
+            while(cursor < source.length){
+                const character = source[cursor] ?? '';
+                if ('"' === character) {
+                    const end = quotedStringEnd(source, cursor);
+                    output += source.slice(cursor, end);
+                    cursor = end;
+                    continue;
+                }
+                const token = scanStructuredReference(source, cursor);
+                if (!token) {
+                    output += character;
+                    cursor += 1;
+                    continue;
+                }
+                const areas = catalog.resolve(token.qualifier, token.reference, currentSheet, currentColumn, currentRow);
+                if (areas.length > 1) throw new SpreadsheetStructuredReferenceError('unsupported', `Structured reference '${token.reference}' resolves to disjoint row areas; the JavaScript fallback requires a contiguous range.`);
+                const ranges = areas.map((area)=>{
+                    const prefix = area.sheetId === currentSheet.id ? '' : `${quoteSheetName(area.sheetName)}!`;
+                    const start = cellAddress(area.startRow, area.startColumn);
+                    const end = cellAddress(area.endRow, area.endColumn);
+                    return `${prefix}${start}${start === end ? '' : `:${end}`}`;
+                });
+                output += 1 === ranges.length ? ranges[0] : `(${ranges.join(',')})`;
+                cursor = token.end;
+            }
+            return hasEquals ? `=${output}` : output;
+        }
+        function scanStructuredReference(source, start) {
+            const qualified = scanQualifier(source, start);
+            let cursor = qualified?.end ?? start;
+            const qualifier = qualified?.name;
+            if ('[' === source[cursor]) {
+                const end = matchingBracket(source, cursor);
+                if (null === end) return null;
+                const content = source.slice(cursor + 1, end - 1);
+                if (!content.startsWith('@') && !content.startsWith('#') && !content.startsWith('[')) return null;
+                return {
+                    end,
+                    qualifier,
+                    reference: source.slice(cursor, end)
+                };
+            }
+            const nameStart = cursor;
+            if (!isNameStart(source[cursor] ?? '')) return null;
+            cursor += 1;
+            while(cursor < source.length && isNameContinue(source[cursor]))cursor += 1;
+            if ('[' !== source[cursor]) return null;
+            const end = matchingBracket(source, cursor);
+            if (null === end) throw invalidReference(source.slice(nameStart, source.length));
+            return {
+                end,
+                qualifier,
+                reference: source.slice(nameStart, end)
+            };
+        }
+        function scanQualifier(source, start) {
+            if ("'" === source[start]) {
+                let cursor = start + 1;
+                let decoded = '';
+                while(cursor < source.length){
+                    const character = source[cursor];
+                    if ("'" === character) {
+                        if ("'" === source[cursor + 1]) {
+                            decoded += "'";
+                            cursor += 2;
+                            continue;
+                        }
+                        if ('!' === source[cursor + 1]) return {
+                            name: decoded,
+                            end: cursor + 2
+                        };
+                        break;
+                    }
+                    decoded += character;
+                    cursor += 1;
+                }
+                return null;
+            }
+            let cursor = start;
+            while(cursor < source.length && isQualifierCharacter(source[cursor]))cursor += 1;
+            if ('!' !== source[cursor] || cursor === start) return null;
+            return {
+                name: source.slice(start, cursor),
+                end: cursor + 1
+            };
+        }
+        function matchingBracket(source, start) {
+            let depth = 0;
+            for(let cursor = start; cursor < source.length; cursor += 1){
+                const character = source[cursor];
+                if ("'" === character) {
+                    cursor += "'" === source[cursor + 1] ? 1 : 0;
+                    continue;
+                }
+                if ('[' === character) depth += 1;
+                else if (']' === character) {
+                    depth -= 1;
+                    if (0 === depth) return cursor + 1;
+                    if (depth < 0) break;
+                }
+            }
+            return null;
+        }
+        function outerGroup(value) {
+            if (!value.startsWith('[')) return null;
+            const end = matchingBracket(value, 0);
+            return end === value.length ? value.slice(1, -1) : null;
+        }
+        function bracketAtom(value) {
+            if (!value.startsWith('[')) return null;
+            const end = matchingBracket(value, 0);
+            return null === end ? null : {
+                atom: value.slice(1, end - 1),
+                consumed: end
+            };
+        }
+        function parseCurrentColumn(value, reference) {
+            if (value.startsWith('[')) {
+                const atom = bracketAtom(value);
+                if (!atom || atom.consumed !== value.length) throw invalidReference(reference);
+                const column = decodeAtom(atom.atom);
+                if (!column) throw invalidReference(reference);
+                return column;
+            }
+            return parsePlainColumn(value, reference);
+        }
+        function parseNestedSelection(content, reference, rows) {
+            const atoms = [];
+            const separators = [];
+            let cursor = 0;
+            while(cursor < content.length){
+                const atom = bracketAtom(content.slice(cursor));
+                if (!atom) throw invalidReference(reference);
+                atoms.push(atom.atom);
+                cursor += atom.consumed;
+                if (cursor === content.length) break;
+                const separator = content[cursor];
+                if (',' !== separator && ':' !== separator) throw invalidReference(reference);
+                separators.push(separator);
+                cursor += 1;
+            }
+            const columns = [];
+            atoms.forEach((atom, index)=>{
+                const item = tableItem(atom);
+                if (item) applyTableItem(rows, item, reference);
+                else {
+                    const column = decodeAtom(atom);
+                    if (!column) throw invalidReference(reference);
+                    columns.push({
+                        index,
+                        name: column
+                    });
+                }
+            });
+            if (0 === columns.length) {
+                if (separators.includes(':')) throw invalidReference(reference);
+                return [
+                    void 0,
+                    void 0
+                ];
+            }
+            if (1 === columns.length) {
+                if (separators.includes(':')) throw invalidReference(reference);
+                return [
+                    columns[0].name,
+                    columns[0].name
+                ];
+            }
+            const first = columns[0];
+            const last = columns[1];
+            if (2 === columns.length && last.index === first.index + 1 && ':' === separators[first.index] && separators.every((separator, index)=>index === first.index || ',' === separator)) return [
+                first.name,
+                last.name
+            ];
+            throw new SpreadsheetStructuredReferenceError('unsupported', 'Disjoint structured-reference columns are not supported.');
+        }
+        function tableItem(value) {
+            const normalized = value.toLocaleLowerCase();
+            if ('#all' === normalized) return 'all';
+            if ('#headers' === normalized) return 'headers';
+            if ('#data' === normalized) return 'data';
+            if ('#totals' === normalized) return 'totals';
+            if ('#this row' === normalized) return 'current';
+        }
+        function applyTableItem(rows, item, reference) {
+            rows['current' === item ? 'current' : item] = true;
+            if (rows.current && (rows.all || rows.headers || rows.data || rows.totals)) throw new SpreadsheetStructuredReferenceError('unsupported', `Structured reference '${reference}' cannot combine #This Row with another item.`);
+        }
+        function parsePlainColumn(value, reference) {
+            if (!value || /[[\],:]/u.test(value)) throw invalidReference(reference);
+            const column = decodeAtom(value);
+            if (!column) throw invalidReference(reference);
+            return column;
+        }
+        function decodeAtom(value) {
+            let output = '';
+            for(let cursor = 0; cursor < value.length; cursor += 1){
+                const character = value[cursor];
+                if ("'" === character) {
+                    const escaped = value[cursor + 1];
+                    if (void 0 === escaped) throw invalidReference(value);
+                    output += escaped;
+                    cursor += 1;
+                } else output += character;
+            }
+            return output;
+        }
+        function missingRows(table, item) {
+            return new SpreadsheetStructuredReferenceError('unsupported', `Structured reference ${item} requires table '${table.name}' to contain that row.`);
+        }
+        function invalidReference(reference) {
+            return new SpreadsheetStructuredReferenceError('invalid', `Structured reference '${reference}' is not in a supported canonical form.`);
+        }
+        function quotedStringEnd(source, start) {
+            for(let cursor = start + 1; cursor < source.length; cursor += 1)if ('"' === source[cursor]) {
+                if ('"' === source[cursor + 1]) {
+                    cursor += 1;
+                    continue;
+                }
+                return cursor + 1;
+            }
+            return source.length;
+        }
+        function cellAddress(row, column) {
+            let value = column + 1;
+            let label = '';
+            while(value > 0){
+                value -= 1;
+                label = String.fromCharCode(65 + value % 26) + label;
+                value = Math.floor(value / 26);
+            }
+            return `${label}${row + 1}`;
+        }
+        function quoteSheetName(name) {
+            return /^[A-Za-z_][A-Za-z0-9_.]*$/u.test(name) ? name : `'${name.replaceAll("'", "''")}'`;
+        }
+        function isNameStart(value) {
+            return /^[A-Za-z_\\?]$/u.test(value);
+        }
+        function isNameContinue(value) {
+            return /^[A-Za-z0-9_.\\?]$/u.test(value);
+        }
+        function isQualifierCharacter(value) {
+            return /^[A-Za-z0-9_.\\?[\]:$]$/u.test(value);
+        }
         async function calculateSpreadsheetInJavaScript(request) {
             validateSpreadsheetCalculationRequest(request);
             const formulaParser = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, 909));
@@ -14035,9 +14611,11 @@
             stack = [];
             calculationOrder = [];
             issues = [];
+            tableCatalog;
             constructor(request, formulaParser){
                 this.request = request;
                 this.formulaParser = formulaParser;
+                this.tableCatalog = new SpreadsheetStructuredReferenceCatalog(request.sheets);
                 for (const sheet of request.sheets){
                     this.sheetsByName.set(sheet.name.toLowerCase(), sheet);
                     for (const cell of sheet.cells)this.cells.set(cellKey(sheet.id, cell.row, cell.column), {
@@ -14108,16 +14686,24 @@
             }
             evaluateFormula(coordinate, indexed) {
                 const formula = indexed.cell.formula ?? '';
+                let expandedFormula;
+                try {
+                    expandedFormula = expandSpreadsheetStructuredReferences(formula, this.tableCatalog, indexed.sheet, coordinate.row, coordinate.column);
+                } catch (error) {
+                    const message = error instanceof SpreadsheetStructuredReferenceError ? error.message : 'Structured reference expansion failed.';
+                    return failedEvaluation(indexed.cell.value, calculationIssue(coordinate, 'office.kernel.spreadsheet.formula_unsupported', message));
+                }
                 const parser = new this.formulaParser.Parser();
                 let unresolvedDependency = false;
                 let unsupportedReference = false;
                 let unsupportedFunction;
                 let materializedRangeCells = 0;
                 parser.setFunction('IFERROR', evaluateParserIfError).setFunction('ROW', (parameters)=>parameters.length ? null : coordinate.row + 1).setFunction('COLUMN', (parameters)=>parameters.length ? null : coordinate.column + 1);
-                parser.on('callFunction', (name, parameters)=>{
+                parser.on('callFunction', (name, parameters, done)=>{
                     const normalized = normalizeSpreadsheetFunctionName(name);
                     const arity = browserScalarFunctionArities.get(normalized);
                     if (!arity || parameters.length < arity[0] || parameters.length > arity[1]) unsupportedFunction ??= name.toUpperCase();
+                    if ('SUBTOTAL' === normalized) done(evaluateParserSubtotal(parameters));
                 });
                 parser.on('callCellValue', (cell, _options, done)=>{
                     const dependency = this.resolveCoordinate(indexed.sheet, cell);
@@ -14141,7 +14727,7 @@
                         return true;
                     }));
                 });
-                const parsed = parser.parse(normalizeFormulaForFortuneParser(formula), {
+                const parsed = parser.parse(normalizeFormulaForFortuneParser(expandedFormula), {
                     sheetId: indexed.sheet.id
                 });
                 if (unsupportedFunction) return failedEvaluation(indexed.cell.value, calculationIssue(coordinate, 'office.kernel.spreadsheet.formula_unsupported', `Formula function '${unsupportedFunction}' is not supported.`));
@@ -14165,7 +14751,8 @@
             }
             rangeValues(currentSheet, start, end, onUnresolvedDependency, onUnsupportedReference, reserveRangeCells) {
                 const startCoordinate = this.resolveCoordinate(currentSheet, start);
-                const endCoordinate = this.resolveCoordinate(currentSheet, end);
+                const rangeSheet = start.sheetName ? this.sheetsByName.get(start.sheetName.toLowerCase()) : currentSheet;
+                const endCoordinate = rangeSheet ? this.resolveCoordinate(rangeSheet, end) : null;
                 if (!startCoordinate || !endCoordinate || startCoordinate.sheetId !== endCoordinate.sheetId) {
                     onUnsupportedReference();
                     return [];
@@ -14344,6 +14931,14 @@
             return sheets.map((sheet)=>({
                     id: sheet.id,
                     name: sheet.name,
+                    ...sheet.tables?.length ? {
+                        tables: sheet.tables.map((table)=>({
+                                ...table,
+                                columns: [
+                                    ...table.columns
+                                ]
+                            }))
+                    } : {},
                     cells: sheet.cells.map((cell)=>({
                             ...cell,
                             value: {