@shbernal/ts-xlsx 2.1.0 → 3.1.0

package/dist/io/xlsb/formula.js

@@ -1,19 +1,35 @@
-import { MAX_COLUMN, numberToColumn } from '../../core/address.js';
-import { quoteSheetName } from '../../core/formula.js';
+import { MAX_COLUMN, MAX_COLUMN_INDEX, MAX_ROW_INDEX, numberToColumn } from '../../core/address.js';
+import { formulaNumberLiteral, quoteSheetName } from '../../core/formula.js';
+import { REF_ERROR } from '../../core/value.js';
+import { XlsbParseError } from './errors.js';
 import { errorCodeFor, RecordReader } from './primitives.js';
-import { FTAB_USER_DEFINED, fixedArityFor, functionNameFor } from './ptg-functions.js';
+import { builtinFunctionAt, FTAB_USER_DEFINED, functionNameFor } from './ptg-functions.js';
 export function decodeFormula(rgce, rgcb, scope) {
-    const tokens = new RecordReader(rgce);
-    const extra = new RecordReader(rgcb);
+    try {
+        return decodeTokens(rgce, rgcb, scope);
+    }
+    catch (error) {
+        if (error instanceof XlsbParseError)
+            return undefined;
+        throw error;
+    }
+}
+function decodeTokens(rgce, rgcb, scope) {
     const stack = [];
-    const push = (text) => {
-        if (text === undefined)
-            return false;
-        stack.push(text);
-        return true;
+    const decode = {
+        tokens: new RecordReader(rgce),
+        extra: new RecordReader(rgcb),
+        stack,
+        scope,
+        push: (text) => {
+            if (text === undefined)
+                return false;
+            stack.push(text);
+            return true;
+        },
     };
-    while (!tokens.done) {
-        if (!step(tokens.u8(), tokens, extra, stack, scope, push))
+    while (!decode.tokens.done) {
+        if (!step(decode.tokens.u8(), decode))
             return undefined;
     }
     return stack.length === 1 ? stack[0] : undefined;
@@ -29,7 +45,8 @@ export function formulaAnchor(rgce, rgcb) {
         return undefined;
     return { row, column: extra.u32() };
 }
-function step(ptg, tokens, extra, stack, scope, push) {
+function step(ptg, decode) {
+    const { tokens, stack, push } = decode;
     const binary = BINARY_OPERATORS.get(ptg);
     if (binary !== undefined) {
         const right = stack.pop();
@@ -54,33 +71,33 @@ function step(ptg, tokens, extra, stack, scope, push) {
         case PTG.Str:
             return push(quoteString(tokens.shortString()));
         case PTG.Attr:
-            return attribute(tokens, stack, push);
+            return attribute(decode);
         case PTG.Err:
             return push(errorCodeFor(tokens.u8()));
         case PTG.Bool:
             return push(tokens.u8() !== 0 ? 'TRUE' : 'FALSE');
         case PTG.Int:
-            return push(String(tokens.u16()));
+            return push(numberLiteral(tokens.u16()));
         case PTG.Num:
-            return push(numberText(tokens.f64()));
+            return push(numberLiteral(tokens.f64()));
         default:
             return ptg >= CLASSED_TOKEN_FLOOR
-                ? operand((ptg & CLASSED_TOKEN_MASK) | CLASSED_TOKEN_FLOOR, tokens, extra, stack, scope, push)
+                ? operand((ptg & CLASSED_TOKEN_MASK) | CLASSED_TOKEN_FLOOR, decode)
                 : false;
     }
 }
-function operand(base, tokens, extra, stack, scope, push) {
+function operand(base, decode) {
+    const { tokens, extra, stack, scope, push } = decode;
     switch (base) {
         case PTG.Array:
             tokens.skip(14);
             return push(arrayConstant(extra));
         case PTG.Func: {
-            const name = functionNameFor(tokens.u16());
-            const arity = name === undefined ? undefined : fixedArityFor(name);
-            return name !== undefined && arity !== undefined && push(call(name, arity, stack));
+            const fn = builtinFunctionAt(tokens.u16());
+            return fn !== undefined && fn[1] !== 'variadic' && push(call(fn[0], fn[1], stack));
         }
         case PTG.FuncVar:
-            return variadicCall(tokens, stack, push);
+            return variadicCall(decode);
         case PTG.Name: {
             return push(scope.names[tokens.u32() - 1]);
         }
@@ -100,16 +117,16 @@ function operand(base, tokens, extra, stack, scope, push) {
         }
         case PTG.RefErr:
             tokens.skip(6);
-            return push(REFERENCE_ERROR);
+            return push(REF_ERROR);
         case PTG.AreaErr:
             tokens.skip(12);
-            return push(REFERENCE_ERROR);
+            return push(REF_ERROR);
         case PTG.RefErr3d:
             tokens.skip(8);
-            return push(REFERENCE_ERROR);
+            return push(REF_ERROR);
         case PTG.AreaErr3d:
             tokens.skip(14);
-            return push(REFERENCE_ERROR);
+            return push(REF_ERROR);
         case PTG.MemArea:
             tokens.skip(6);
             return skipExtraRanges(extra);
@@ -117,7 +134,7 @@ function operand(base, tokens, extra, stack, scope, push) {
             return false;
     }
 }
-function attribute(tokens, stack, push) {
+function attribute({ tokens, stack, push }) {
     const flags = tokens.u8();
     const data = tokens.u16();
     if ((flags & ATTR_CHOOSE) !== 0) {
@@ -128,7 +145,7 @@ function attribute(tokens, stack, push) {
         return push(call('SUM', 1, stack));
     return true;
 }
-function variadicCall(tokens, stack, push) {
+function variadicCall({ tokens, stack, push }) {
     const count = tokens.u8() & FUNCVAR_PARAM_MASK;
     const index = tokens.u16() & FUNCVAR_INDEX_MASK;
     if (index !== FTAB_USER_DEFINED) {
@@ -167,7 +184,7 @@ function arrayConstant(extra) {
 function arrayElement(extra) {
     switch (extra.u8()) {
         case SER_NUM:
-            return numberText(extra.f64());
+            return numberLiteral(extra.f64());
         case SER_STR:
             return quoteString(extra.shortString());
         case SER_BOOL:
@@ -212,7 +229,7 @@ function rangeText(rowFirst, rowLast, packedFirst, packedLast) {
         const last = columnOnly(packedLast);
         return first === undefined || last === undefined ? undefined : `${first}:${last}`;
     }
-    if ((packedFirst & COLUMN_MASK) === 0 && (packedLast & COLUMN_MASK) === MAX_COLUMN - 1) {
+    if ((packedFirst & COLUMN_MASK) === 0 && (packedLast & COLUMN_MASK) === MAX_COLUMN_INDEX) {
         return rowFirst > MAX_ROW_INDEX || rowLast > MAX_ROW_INDEX
             ? undefined
             : `${rowOnly(rowFirst, packedFirst)}:${rowOnly(rowLast, packedLast)}`;
@@ -233,10 +250,9 @@ function rowOnly(row, packedColumn) {
 function quoteString(text) {
     return `"${text.replace(/"/g, '""')}"`;
 }
-function numberText(value) {
-    return String(value).toUpperCase();
+function numberLiteral(value) {
+    return Number.isFinite(value) ? formulaNumberLiteral(value) : undefined;
 }
-const REFERENCE_ERROR = '#REF!';
 const BINARY_OPERATORS = new Map([
     [0x03, '+'],
     [0x04, '-'],
@@ -291,7 +307,6 @@ const FUNCVAR_INDEX_MASK = 0x7fff;
 const COLUMN_MASK = 0x3fff;
 const COLUMN_RELATIVE = 0x4000;
 const ROW_RELATIVE = 0x8000;
-const MAX_ROW_INDEX = 1048575;
 const SER_NUM = 0x00;
 const SER_STR = 0x01;
 const SER_BOOL = 0x02;

package/dist/io/xlsb/primitives.js

@@ -1,15 +1,18 @@
+import { decodeUtf16le } from '../../bytes.js';
 import { isErrorCode } from '../../core/value.js';
+import { hex } from '../../hex.js';
 import { XlsbParseError } from './errors.js';
-const CHARS_PER_BATCH = 4096;
 const NULL_STRING_LENGTH = 0xffffffff;
 const rkScratch = new DataView(new ArrayBuffer(8));
 export class RecordReader {
     #data;
-    #view;
+    #cachedView;
     #offset = 0;
     constructor(data) {
         this.#data = data;
-        this.#view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    }
+    get #view() {
+        return (this.#cachedView ??= new DataView(this.#data.buffer, this.#data.byteOffset, this.#data.byteLength));
     }
     get remaining() {
         return this.#data.length - this.#offset;
@@ -89,16 +92,7 @@ export class RecordReader {
     }
     #characters(count) {
         const start = this.#take(count * 2);
-        let text = '';
-        let batch = [];
-        for (let index = 0; index < count; index++) {
-            batch.push(this.#view.getUint16(start + index * 2, true));
-            if (batch.length === CHARS_PER_BATCH) {
-                text += String.fromCharCode(...batch);
-                batch = [];
-            }
-        }
-        return batch.length > 0 ? text + String.fromCharCode(...batch) : text;
+        return decodeUtf16le(this.#data.subarray(start, start + count * 2));
     }
     #take(count) {
         if (count > this.remaining) {
@@ -144,5 +138,5 @@ function colorByType(type, index, alpha, red, green, blue) {
     }
 }
 function hexByte(value) {
-    return value.toString(16).toUpperCase().padStart(2, '0');
+    return hex(value, 2);
 }

package/dist/io/xlsb/ptg-functions.d.ts

@@ -1,16 +1,25 @@
 /** The index [MS-XLS] reserves for a call whose name is given by the token stream's first operand. */
 export declare const FTAB_USER_DEFINED = 255;
-/** Look up a built-in function name by its `iftab` index, or `undefined` if the index names none. */
-export declare function functionNameFor(index: number): string | undefined;
 /**
- * How many arguments a fixed-arity function takes, or `undefined` for one whose argument count varies.
+ * One built-in function: the name an `iftab` index means, and how many arguments it takes.
  *
- * A `PtgFunc` token states only *which* function is called, never with how many arguments: it is the
- * token Excel emits precisely because the count is implied by the function. So decoding `ROUND(A1,2)`
- * back from its two operands and one call token is impossible without this: the arity is the only
- * thing that says which operands on the stack belong to the call. (`PtgFuncVar` carries its own count
- * and needs none of this; the two token forms partition the table between them.)
+ * The arity is not decoration. A `PtgFunc` token states only *which* function is called, never with
+ * how many arguments: it is the token Excel emits precisely because the count is implied by the
+ * function. So decoding `ROUND(A1,2)` back from its two operands and one call token is impossible
+ * without it, and `'variadic'` says the call cannot be spelled with that token at all (`PtgFuncVar`
+ * carries its own count; the two token forms partition the table between them). Transcribed from the
+ * parameter grammar each function's [MS-XLS] 2.5.198.17 entry states.
  *
- * Transcribed from the parameter grammar each function's [MS-XLS] 2.5.198.17 entry states.
+ * It used to live in a second table keyed by name, which let an entry exist in one and not the other
+ * with nothing to say so. A function whose arity was never transcribed simply read as variadic, and a
+ * `PtgFunc` citing it then took the wrong run of operands off the stack and produced a different
+ * formula, silently. Recording it beside the name makes "no arity recorded" unrepresentable: the
+ * compiler asks for it once per entry, and `'variadic'` becomes a decision written down rather than
+ * an absence that looks like one.
  */
-export declare function fixedArityFor(name: string): number | undefined;
+export type FunctionEntry = readonly [name: string, arity: number | 'variadic'];
+/** The built-in function an `iftab` index names, or `undefined` if the index names none. */
+export declare function builtinFunctionAt(index: number): FunctionEntry | undefined;
+/** Look up a built-in function name by its `iftab` index, or `undefined` if the index names none. */
+export declare function functionNameFor(index: number): string | undefined;
+export declare const FTAB: readonly (FunctionEntry | undefined)[];