@a3s-lab/office 0.35.0 → 0.37.0

package/dist/0~7048.js

@@ -1352,6 +1352,13 @@ const browserScalarFunctionArities = new Map([
             1
         ]
     ],
+    [
+        'SUBTOTAL',
+        [
+            2,
+            255
+        ]
+    ],
     [
         'SUM',
         [
@@ -1372,6 +1379,90 @@ function normalizeSpreadsheetFunctionName(name) {
     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 = '';
@@ -1462,6 +1553,7 @@ function validateSpreadsheetCalculationRequest(request) {
         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}`;
@@ -1473,6 +1565,68 @@ function validateSpreadsheetCalculationRequest(request) {
     }
     for (const target of request.targets ?? [])if (!sheetIds.has(target.sheetId) || !boundedSpreadsheetIndex(target.row, office_kernel_spreadsheet_protocol_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_protocol_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;
 }
@@ -1566,6 +1720,428 @@ function isParserErrorValue(value) {
     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 import("@fortune-sheet/formula-parser");
@@ -1581,9 +2157,11 @@ class JavaScriptSpreadsheetEvaluator {
     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), {
@@ -1654,16 +2232,24 @@ class JavaScriptSpreadsheetEvaluator {
     }
     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);
@@ -1687,7 +2273,7 @@ class JavaScriptSpreadsheetEvaluator {
                 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.`));
@@ -1711,7 +2297,8 @@ class JavaScriptSpreadsheetEvaluator {
     }
     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 [];