@borgar/fx 4.13.0 → 5.0.0

package/lib/isType.spec.ts

@@ -0,0 +1,208 @@
+import { describe, test, expect } from 'vitest';
+import {
+  REF_RANGE, REF_BEAM, REF_NAMED, REF_TERNARY, REF_STRUCT,
+  FX_PREFIX, WHITESPACE, NEWLINE,
+  FUNCTION, OPERATOR,
+  ERROR, STRING, NUMBER, BOOLEAN
+} from './constants.ts';
+import { isRange, isReference, isLiteral, isError, isWhitespace, isFunction, isFxPrefix, isOperator } from './isType.ts';
+
+describe('isRange', () => {
+  test('returns false for non-range types', () => {
+    expect(isRange(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isRange({})).toBe(false);
+    expect(isRange({ type: BOOLEAN })).toBe(false);
+    expect(isRange({ type: ERROR })).toBe(false);
+    expect(isRange({ type: FUNCTION })).toBe(false);
+    expect(isRange({ type: FX_PREFIX })).toBe(false);
+    expect(isRange({ type: NEWLINE })).toBe(false);
+    expect(isRange({ type: NUMBER })).toBe(false);
+    expect(isRange({ type: OPERATOR })).toBe(false);
+    expect(isRange({ type: REF_NAMED })).toBe(false);
+    expect(isRange({ type: REF_STRUCT })).toBe(false);
+    expect(isRange({ type: STRING })).toBe(false);
+    expect(isRange({ type: WHITESPACE })).toBe(false);
+  });
+
+  test('returns true for range types', () => {
+    expect(isRange({ type: REF_BEAM })).toBe(true);
+    expect(isRange({ type: REF_RANGE })).toBe(true);
+    expect(isRange({ type: REF_TERNARY })).toBe(true);
+  });
+});
+
+describe('isReference', () => {
+  test('returns false for non-reference types', () => {
+    expect(isReference(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isReference({})).toBe(false);
+    expect(isReference({ type: BOOLEAN })).toBe(false);
+    expect(isReference({ type: ERROR })).toBe(false);
+    expect(isReference({ type: FUNCTION })).toBe(false);
+    expect(isReference({ type: FX_PREFIX })).toBe(false);
+    expect(isReference({ type: NEWLINE })).toBe(false);
+    expect(isReference({ type: NUMBER })).toBe(false);
+    expect(isReference({ type: OPERATOR })).toBe(false);
+    expect(isReference({ type: STRING })).toBe(false);
+    expect(isReference({ type: WHITESPACE })).toBe(false);
+  });
+
+  test('returns true for reference types', () => {
+    expect(isReference({ type: REF_BEAM })).toBe(true);
+    expect(isReference({ type: REF_NAMED })).toBe(true);
+    expect(isReference({ type: REF_RANGE })).toBe(true);
+    expect(isReference({ type: REF_STRUCT })).toBe(true);
+    expect(isReference({ type: REF_TERNARY })).toBe(true);
+  });
+});
+
+describe('isLiteral', () => {
+  test('returns false for non-literal types', () => {
+    expect(isLiteral(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isLiteral({})).toBe(false);
+    expect(isLiteral({ type: FUNCTION })).toBe(false);
+    expect(isLiteral({ type: FX_PREFIX })).toBe(false);
+    expect(isLiteral({ type: NEWLINE })).toBe(false);
+    expect(isLiteral({ type: OPERATOR })).toBe(false);
+    expect(isLiteral({ type: REF_BEAM })).toBe(false);
+    expect(isLiteral({ type: REF_NAMED })).toBe(false);
+    expect(isLiteral({ type: REF_RANGE })).toBe(false);
+    expect(isLiteral({ type: REF_STRUCT })).toBe(false);
+    expect(isLiteral({ type: REF_TERNARY })).toBe(false);
+    expect(isLiteral({ type: WHITESPACE })).toBe(false);
+  });
+
+  test('returns true for literal types', () => {
+    expect(isLiteral({ type: BOOLEAN })).toBe(true);
+    expect(isLiteral({ type: ERROR })).toBe(true);
+    expect(isLiteral({ type: NUMBER })).toBe(true);
+    expect(isLiteral({ type: STRING })).toBe(true);
+  });
+});
+
+describe('isError', () => {
+  test('returns false for non-error types', () => {
+    expect(isError(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isError({})).toBe(false);
+    expect(isError({ type: BOOLEAN })).toBe(false);
+    expect(isError({ type: FUNCTION })).toBe(false);
+    expect(isError({ type: FX_PREFIX })).toBe(false);
+    expect(isError({ type: NEWLINE })).toBe(false);
+    expect(isError({ type: NUMBER })).toBe(false);
+    expect(isError({ type: OPERATOR })).toBe(false);
+    expect(isError({ type: REF_BEAM })).toBe(false);
+    expect(isError({ type: REF_NAMED })).toBe(false);
+    expect(isError({ type: REF_RANGE })).toBe(false);
+    expect(isError({ type: REF_STRUCT })).toBe(false);
+    expect(isError({ type: REF_TERNARY })).toBe(false);
+    expect(isError({ type: STRING })).toBe(false);
+    expect(isError({ type: WHITESPACE })).toBe(false);
+  });
+
+  test('returns true for error type', () => {
+    expect(isError({ type: ERROR })).toBe(true);
+  });
+});
+
+describe('isWhitespace', () => {
+  test('returns false for non-whitespace types', () => {
+    expect(isWhitespace(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isWhitespace({})).toBe(false);
+    expect(isWhitespace({ type: BOOLEAN })).toBe(false);
+    expect(isWhitespace({ type: ERROR })).toBe(false);
+    expect(isWhitespace({ type: FUNCTION })).toBe(false);
+    expect(isWhitespace({ type: FX_PREFIX })).toBe(false);
+    expect(isWhitespace({ type: NUMBER })).toBe(false);
+    expect(isWhitespace({ type: OPERATOR })).toBe(false);
+    expect(isWhitespace({ type: REF_BEAM })).toBe(false);
+    expect(isWhitespace({ type: REF_NAMED })).toBe(false);
+    expect(isWhitespace({ type: REF_RANGE })).toBe(false);
+    expect(isWhitespace({ type: REF_STRUCT })).toBe(false);
+    expect(isWhitespace({ type: REF_TERNARY })).toBe(false);
+    expect(isWhitespace({ type: STRING })).toBe(false);
+  });
+
+  test('returns true for whitespace types', () => {
+    expect(isWhitespace({ type: NEWLINE })).toBe(true);
+    expect(isWhitespace({ type: WHITESPACE })).toBe(true);
+  });
+});
+
+describe('isFunction', () => {
+  test('returns false for non-function types', () => {
+    expect(isFunction(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isFunction({})).toBe(false);
+    expect(isFunction({ type: BOOLEAN })).toBe(false);
+    expect(isFunction({ type: ERROR })).toBe(false);
+    expect(isFunction({ type: FX_PREFIX })).toBe(false);
+    expect(isFunction({ type: NEWLINE })).toBe(false);
+    expect(isFunction({ type: NUMBER })).toBe(false);
+    expect(isFunction({ type: OPERATOR })).toBe(false);
+    expect(isFunction({ type: REF_BEAM })).toBe(false);
+    expect(isFunction({ type: REF_NAMED })).toBe(false);
+    expect(isFunction({ type: REF_RANGE })).toBe(false);
+    expect(isFunction({ type: REF_STRUCT })).toBe(false);
+    expect(isFunction({ type: REF_TERNARY })).toBe(false);
+    expect(isFunction({ type: STRING })).toBe(false);
+    expect(isFunction({ type: WHITESPACE })).toBe(false);
+  });
+
+  test('returns true for function type', () => {
+    expect(isFunction({ type: FUNCTION })).toBe(true);
+  });
+});
+
+describe('isFxPrefix', () => {
+  test('returns false for non-prefix types', () => {
+    expect(isFxPrefix(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isFxPrefix({})).toBe(false);
+    expect(isFxPrefix({ type: BOOLEAN })).toBe(false);
+    expect(isFxPrefix({ type: ERROR })).toBe(false);
+    expect(isFxPrefix({ type: FUNCTION })).toBe(false);
+    expect(isFxPrefix({ type: NEWLINE })).toBe(false);
+    expect(isFxPrefix({ type: NUMBER })).toBe(false);
+    expect(isFxPrefix({ type: OPERATOR })).toBe(false);
+    expect(isFxPrefix({ type: REF_BEAM })).toBe(false);
+    expect(isFxPrefix({ type: REF_NAMED })).toBe(false);
+    expect(isFxPrefix({ type: REF_RANGE })).toBe(false);
+    expect(isFxPrefix({ type: REF_STRUCT })).toBe(false);
+    expect(isFxPrefix({ type: REF_TERNARY })).toBe(false);
+    expect(isFxPrefix({ type: STRING })).toBe(false);
+    expect(isFxPrefix({ type: WHITESPACE })).toBe(false);
+  });
+
+  test('returns true for FX_PREFIX type', () => {
+    expect(isFxPrefix({ type: FX_PREFIX })).toBe(true);
+  });
+});
+
+describe('isOperator', () => {
+  test('returns false for non-operator types', () => {
+    expect(isOperator(null)).toBe(false);
+    // @ts-expect-error -- testing invalid input
+    expect(isOperator({})).toBe(false);
+    expect(isOperator({ type: BOOLEAN })).toBe(false);
+    expect(isOperator({ type: ERROR })).toBe(false);
+    expect(isOperator({ type: FUNCTION })).toBe(false);
+    expect(isOperator({ type: FX_PREFIX })).toBe(false);
+    expect(isOperator({ type: NEWLINE })).toBe(false);
+    expect(isOperator({ type: NUMBER })).toBe(false);
+    expect(isOperator({ type: REF_BEAM })).toBe(false);
+    expect(isOperator({ type: REF_NAMED })).toBe(false);
+    expect(isOperator({ type: REF_RANGE })).toBe(false);
+    expect(isOperator({ type: REF_STRUCT })).toBe(false);
+    expect(isOperator({ type: REF_TERNARY })).toBe(false);
+    expect(isOperator({ type: STRING })).toBe(false);
+    expect(isOperator({ type: WHITESPACE })).toBe(false);
+  });
+
+  test('returns true for operator type', () => {
+    expect(isOperator({ type: OPERATOR })).toBe(true);
+  });
+});

package/lib/{isType.js → isType.ts}

@@ -3,7 +3,8 @@ import {
   FX_PREFIX, WHITESPACE, NEWLINE,
   FUNCTION, OPERATOR,
   ERROR, STRING, NUMBER, BOOLEAN
-} from './constants.js';
+} from './constants.ts';
+import type { Token } from './types.ts';
 
 /**
  * Determines whether the specified token is a range.
@@ -12,10 +13,10 @@ import {
  * (`A1` or `A1:B2`), REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), or
  * REF_BEAM (`A:A` or `1:1`). In all other cases `false` is returned.
  *
- * @param {any} token A token
- * @returns {boolean} True if the specified token is range, False otherwise.
+ * @param token A token
+ * @returns True if the specified token is range, False otherwise.
  */
-export function isRange (token) {
+export function isRange (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && (
     token.type === REF_RANGE ||
     token.type === REF_BEAM ||
@@ -30,10 +31,10 @@ export function isRange (token) {
  * REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), REF_BEAM (`A:A` or `1:1`),
  * or REF_NAMED (`myrange`). In all other cases `false` is returned.
  *
- * @param {any} token The token
- * @returns {boolean} True if the specified token is reference, False otherwise.
+ * @param token The token
+ * @returns True if the specified token is reference, False otherwise.
  */
-export function isReference (token) {
+export function isReference (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && (
     token.type === REF_RANGE ||
     token.type === REF_BEAM ||
@@ -50,10 +51,10 @@ export function isReference (token) {
  * ERROR (`#VALUE!`), NUMBER (123.4), or STRING (`"lorem ipsum"`). In all other
  * cases `false` is returned.
  *
- * @param {any} token The token
- * @returns {boolean} True if the specified token is literal, False otherwise.
+ * @param token The token
+ * @returns True if the specified token is literal, False otherwise.
  */
-export function isLiteral (token) {
+export function isLiteral (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && (
     token.type === BOOLEAN ||
     token.type === ERROR ||
@@ -68,10 +69,10 @@ export function isLiteral (token) {
  * Returns `true` if the input is a token of type ERROR (`#VALUE!`). In all
  * other cases `false` is returned.
  *
- * @param {any} token The token
- * @returns {boolean} True if the specified token is error, False otherwise.
+ * @param token The token
+ * @returns True if the specified token is error, False otherwise.
  */
-export function isError (token) {
+export function isError (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && token.type === ERROR;
 }
 
@@ -81,10 +82,10 @@ export function isError (token) {
  * Returns `true` if the input is a token of type WHITESPACE (` `) or
  * NEWLINE (`\n`). In all other cases `false` is returned.
  *
- * @param {any} token The token
- * @returns {boolean} True if the specified token is whitespace, False otherwise.
+ * @param token The token
+ * @returns True if the specified token is whitespace, False otherwise.
  */
-export function isWhitespace (token) {
+export function isWhitespace (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && (
     token.type === WHITESPACE ||
     token.type === NEWLINE
@@ -97,10 +98,10 @@ export function isWhitespace (token) {
  * Returns `true` if the input is a token of type FUNCTION.
  * In all other cases `false` is returned.
  *
- * @param {any} token The token
- * @returns {boolean} True if the specified token is function, False otherwise.
+ * @param token The token
+ * @returns True if the specified token is function, False otherwise.
  */
-export function isFunction (token) {
+export function isFunction (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && token.type === FUNCTION;
 }
 
@@ -108,10 +109,10 @@ export function isFunction (token) {
  * Returns `true` if the input is a token of type FX_PREFIX (leading `=` in
  * formula). In all other cases `false` is returned.
  *
- * @param {any} token The token
- * @returns {boolean} True if the specified token is effects prefix, False otherwise.
+ * @param token The token
+ * @returns True if the specified token is effects prefix, False otherwise.
  */
-export function isFxPrefix (token) {
+export function isFxPrefix (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && token.type === FX_PREFIX;
 }
 
@@ -121,9 +122,9 @@ export function isFxPrefix (token) {
  * Returns `true` if the input is a token of type OPERATOR (`+` or `:`). In all
  * other cases `false` is returned.
  *
- * @param {any} token The token
- * @returns {boolean} True if the specified token is operator, False otherwise.
+ * @param token The token
+ * @returns True if the specified token is operator, False otherwise.
  */
-export function isOperator (token) {
+export function isOperator (token?: Pick<Token, 'type'> | null): boolean {
   return !!token && token.type === OPERATOR;
 }

package/lib/lexers/{advRangeOp.js → advRangeOp.ts}

@@ -1,7 +1,7 @@
 const PERIOD = 46;
 const COLON = 58;
 
-export function advRangeOp (str, pos) {
+export function advRangeOp (str: string, pos: number): number {
   const c0 = str.charCodeAt(pos);
   if (c0 === PERIOD) {
     const c1 = str.charCodeAt(pos + 1);

package/lib/lexers/{canEndRange.js → canEndRange.ts}

@@ -1,5 +1,5 @@
 // regular: [A-Za-z0-9_\u00a1-\uffff]
-export function canEndRange (str, pos) {
+export function canEndRange (str: string, pos: number): boolean {
   const c = str.charCodeAt(pos);
   return !(
     (c >= 65 && c <= 90) || // A-Z
@@ -11,7 +11,7 @@ export function canEndRange (str, pos) {
 }
 
 // partial: [A-Za-z0-9_($.]
-export function canEndPartialRange (str, pos) {
+export function canEndPartialRange (str: string, pos: number): boolean {
   const c = str.charCodeAt(pos);
   return !(
     (c >= 65 && c <= 90) || // A-Z

package/lib/lexers/{lexBoolean.js → lexBoolean.ts}

@@ -1,6 +1,21 @@
-import { BOOLEAN } from '../constants.js';
+import { BOOLEAN } from '../constants.ts';
+import type { Token } from '../types.ts';
 
-export function lexBoolean (str, pos) {
+function preventMatch (c: number) {
+  return (
+    (c >= 65 && c <= 90) || // A-Z
+    (c >= 97 && c <= 122) || // a-z
+    (c >= 48 && c <= 57) || // 0-9
+    (c === 95) || // _
+    (c === 92) || // \
+    (c === 40) || // (
+    (c === 46) || // .
+    (c === 63) || // ?
+    (c > 0xA0) // \u00a1-\uffff
+  );
+}
+
+export function lexBoolean (str: string, pos: number): Token | undefined {
   // "true" (case insensitive)
   const c0 = str.charCodeAt(pos);
   if (c0 === 84 || c0 === 116) {
@@ -10,8 +25,10 @@ export function lexBoolean (str, pos) {
       if (c2 === 85 || c2 === 117) {
         const c3 = str.charCodeAt(pos + 3);
         if (c3 === 69 || c3 === 101) {
-          // non char to follow?
-          return { type: BOOLEAN, value: str.slice(pos, pos + 4) };
+          const c4 = str.charCodeAt(pos + 4);
+          if (!preventMatch(c4)) {
+            return { type: BOOLEAN, value: str.slice(pos, pos + 4) };
+          }
         }
       }
     }
@@ -26,8 +43,10 @@ export function lexBoolean (str, pos) {
         if (c3 === 83 || c3 === 115) {
           const c4 = str.charCodeAt(pos + 4);
           if (c4 === 69 || c4 === 101) {
-            // non char to follow?
-            return { type: BOOLEAN, value: str.slice(pos, pos + 5) };
+            const c5 = str.charCodeAt(pos + 5);
+            if (!preventMatch(c5)) {
+              return { type: BOOLEAN, value: str.slice(pos, pos + 5) };
+            }
           }
         }
       }

package/lib/lexers/{lexContext.js → lexContext.ts}

@@ -1,4 +1,5 @@
-import { CONTEXT, CONTEXT_QUOTE } from '../constants.js';
+import { CONTEXT, CONTEXT_QUOTE } from '../constants.ts';
+import type { Token } from '../types.ts';
 
 const QUOT_SINGLE = 39; // '
 const BR_OPEN = 91; // [
@@ -7,10 +8,10 @@ const EXCL = 33; // !
 
 // xlsx xml uses a variant of the syntax that has external references in
 // bracets. Any of: [1]Sheet1!A1, '[1]Sheet one'!A1, [1]!named
-export function lexContext (str, pos, options) {
+export function lexContextQuoted (str: string, pos: number, options: { xlsx: boolean }): Token | undefined {
   const c0 = str.charCodeAt(pos);
-  let br1;
-  let br2;
+  let br1: number;
+  let br2: number;
   // quoted context: '(?:''|[^'])*('|$)(?=!)
   if (c0 === QUOT_SINGLE) {
     const start = pos;
@@ -44,8 +45,15 @@ export function lexContext (str, pos, options) {
       pos++;
     }
   }
-  // unquoted context
-  else if (c0 !== EXCL) {
+}
+
+// xlsx xml uses a variant of the syntax that has external references in
+// bracets. Any of: [1]Sheet1!A1, '[1]Sheet one'!A1, [1]!named
+export function lexContextUnquoted (str: string, pos: number, options: { xlsx: boolean }): Token | undefined {
+  const c0 = str.charCodeAt(pos);
+  let br1: number;
+  let br2: number;
+  if (c0 !== QUOT_SINGLE && c0 !== EXCL) {
     const start = pos;
     while (pos < str.length) {
       const c = str.charCodeAt(pos);

package/lib/lexers/{lexError.js → lexError.ts}

@@ -1,10 +1,10 @@
-/* eslint-disable no-mixed-operators */
-import { ERROR } from '../constants.js';
+import { ERROR } from '../constants.ts';
+import type { Token } from '../types.ts';
 
 const re_ERROR = /#(?:NAME\?|FIELD!|CALC!|VALUE!|REF!|DIV\/0!|NULL!|NUM!|N\/A|GETTING_DATA\b|SPILL!|UNKNOWN!|SYNTAX\?|ERROR!|CONNECT!|BLOCKED!|EXTERNAL!)/iy;
 const HASH = 35;
 
-export function lexError (str, pos) {
+export function lexError (str: string, pos: number): Token | undefined {
   if (str.charCodeAt(pos) === HASH) {
     re_ERROR.lastIndex = pos;
     const m = re_ERROR.exec(str);

package/lib/lexers/{lexFunction.js → lexFunction.ts}

@@ -1,9 +1,10 @@
-import { FUNCTION } from '../constants.js';
+import { FUNCTION } from '../constants.ts';
+import type { Token } from '../types.ts';
 
 const PAREN_OPEN = 40;
 
 // [A-Za-z_]+[A-Za-z\d_.]*(?=\()
-export function lexFunction (str, pos) {
+export function lexFunction (str: string, pos: number): Token | undefined {
   const start = pos;
   // starts with: a-zA-Z_
   let c = str.charCodeAt(pos);

package/lib/lexers/lexNameFuncCntx.ts

@@ -0,0 +1,112 @@
+import { CONTEXT, FUNCTION, REF_NAMED, UNKNOWN } from '../constants.ts';
+import type { Token } from '../types.ts';
+import { lexContextUnquoted } from './lexContext.ts';
+
+const BR_OPEN = 91; // [
+const PAREN_OPEN = 40;
+const EXCL = 33; // !
+const OFFS = 32;
+
+// build a map of characters to allow-bitmasks
+const ALLOWED = new Uint8Array(180 - OFFS);
+const OK_NAME_0 = 0b000001;
+const OK_FUNC_0 = 0b000010;
+const OK_CNTX_0 = 0b000100;
+const OK_NAME_N = 0b001000;
+const OK_FUNC_N = 0b010000;
+const OK_CNTX_N = 0b100000;
+const OK_0 = OK_NAME_0 | OK_FUNC_0 | OK_CNTX_0;
+const OK_N = OK_NAME_N | OK_FUNC_N | OK_CNTX_N;
+const OK_HIGHCHAR = OK_NAME_0 | OK_NAME_N | OK_CNTX_0 | OK_CNTX_N;
+for (let c = OFFS; c < 180; c++) {
+  const char = String.fromCharCode(c);
+  const n0 = /^[a-zA-Z_\\\u00a1-\uffff]$/.test(char);
+  const f0 = /^[a-zA-Z_]$/.test(char);
+  const nN = /^[a-zA-Z0-9_.\\?\u00a1-\uffff]$/.test(char);
+  const fN = /^[a-zA-Z0-9_.]$/.test(char);
+  const cX = /^[a-zA-Z0-9_.¡¤§¨ª\u00ad¯-\uffff]$/.test(char);
+  ALLOWED[c - OFFS] = (
+    (n0 ? OK_NAME_0 : 0) |
+    (nN ? OK_NAME_N : 0) |
+    (f0 ? OK_FUNC_0 : 0) |
+    (fN ? OK_FUNC_N : 0) |
+    (cX ? OK_CNTX_0 : 0) |
+    (cX ? OK_CNTX_N : 0)
+  );
+}
+
+function nameOrUnknown (str, s, start, pos, name) {
+  const len = pos - start;
+  if (name && len && len < 255) {
+    // names starting with \ must be at least 3 char long
+    if (s === 92 && len < 3) {
+      return;
+    }
+    // single characters R and C are forbidden as names
+    if (len === 1 && (s === 114 || s === 82 || s === 99 || s === 67)) {
+      return;
+    }
+    return { type: REF_NAMED, value: str.slice(start, pos) };
+  }
+  return { type: UNKNOWN, value: str.slice(start, pos) };
+}
+
+export function lexNameFuncCntx (
+  str: string,
+  pos: number,
+  opts: { xlsx: boolean }
+): Token | undefined {
+  const start = pos;
+
+  const s = str.charCodeAt(pos);
+  const a = s > 180 ? OK_HIGHCHAR : ALLOWED[s - OFFS];
+  // name: [a-zA-Z_\\\u00a1-\uffff]
+  // func: [a-zA-Z_]
+  // cntx: [a-zA-Z_0-9.¡¤§¨ª\u00ad¯-\uffff]
+  if (((a & OK_CNTX_0) && !(a & OK_NAME_0) && !(a & OK_FUNC_0)) || s === BR_OPEN) {
+    // its a context so delegate to that lexer
+    return lexContextUnquoted(str, pos, opts);
+  }
+  if (!(a & OK_0)) {
+    return;
+  }
+  let name = (a & OK_NAME_0) ? 1 : 0;
+  let func = (a & OK_FUNC_0) ? 1 : 0;
+  let cntx = (a & OK_CNTX_0) ? 1 : 0;
+  pos++;
+
+  let c: number;
+  do {
+    c = str.charCodeAt(pos);
+    const a = s > 180 ? OK_HIGHCHAR : ALLOWED[c - OFFS] ?? 0;
+    if (a & OK_N) {
+      // name: [a-zA-Z_0-9.\\?\u00a1-\uffff]
+      // func: [a-zA-Z_0-9.]
+      // cntx: [a-zA-Z_0-9.¡¤§¨ª\u00ad¯-\uffff]
+      if (name && !(a & OK_NAME_N)) {
+        name = 0;
+      }
+      if (func && !(a & OK_FUNC_N)) {
+        func = 0;
+      }
+      if (cntx && !(a & OK_CNTX_N)) {
+        cntx = 0;
+      }
+    }
+    else {
+      if (c === PAREN_OPEN && func) {
+        return { type: FUNCTION, value: str.slice(start, pos) };
+      }
+      else if (c === EXCL && cntx) {
+        return { type: CONTEXT, value: str.slice(start, pos) };
+      }
+      return nameOrUnknown(str, s, start, pos, name);
+    }
+    pos++;
+  }
+  while ((name || func || cntx) && pos < str.length);
+
+  if (start !== pos) {
+    return nameOrUnknown(str, s, start, pos, name);
+  }
+}

package/lib/lexers/{lexNamed.js → lexNamed.ts}

@@ -1,5 +1,5 @@
-/* eslint-disable max-len */
-import { REF_NAMED } from '../constants.js';
+import { REF_NAMED } from '../constants.ts';
+import type { Token } from '../types.ts';
 
 // The advertized named ranges rules are a bit off from what Excel seems to do.
 // In the "extended range" of chars, it looks like it allows most things above
@@ -8,7 +8,7 @@ import { REF_NAMED } from '../constants.js';
 //
 // I've simplified to allowing everything above U+00A1:
 // /^[a-zA-Z\\_\u00a1-\uffff][a-zA-Z0-9\\_.?\u00a1-\uffff]{0,254}/
-export function lexNamed (str, pos) {
+export function lexNamed (str: string, pos: number): Token | undefined {
   const start = pos;
   // starts with: [a-zA-Z\\_\u00a1-\uffff]
   const s = str.charCodeAt(pos);
@@ -25,7 +25,7 @@ export function lexNamed (str, pos) {
     return;
   }
   // has any number of: [a-zA-Z0-9\\_.?\u00a1-\uffff]
-  let c;
+  let c: number;
   do {
     c = str.charCodeAt(pos);
     if (

package/lib/lexers/{lexNewLine.js → lexNewLine.ts}

@@ -1,6 +1,7 @@
-import { NEWLINE } from '../constants.js';
+import { NEWLINE } from '../constants.ts';
+import type { Token } from '../types.ts';
 
-export function lexNewLine (str, pos) {
+export function lexNewLine (str: string, pos: number): Token | undefined {
   const start = pos;
   while (str.charCodeAt(pos) === 10) {
     pos++;

package/lib/lexers/{lexNumber.js → lexNumber.ts}

@@ -1,6 +1,7 @@
-import { NUMBER } from '../constants.js';
+import { NUMBER } from '../constants.ts';
+import type { Token } from '../types.ts';
 
-function advDigits (str, pos) {
+function advDigits (str: string, pos: number): number {
   const start = pos;
   do {
     const c = str.charCodeAt(pos);
@@ -14,7 +15,7 @@ function advDigits (str, pos) {
 }
 
 // \d+(\.\d+)?(?:[eE][+-]?\d+)?
-export function lexNumber (str, pos) {
+export function lexNumber (str: string, pos: number): Token | undefined {
   const start = pos;
 
   // integer

package/lib/lexers/{lexOperator.js → lexOperator.ts}

@@ -1,6 +1,7 @@
-import { OPERATOR } from '../constants.js';
+import { OPERATOR } from '../constants.ts';
+import type { Token } from '../types.ts';
 
-export function lexOperator (str, pos) {
+export function lexOperator (str: string, pos: number): Token | undefined {
   const c0 = str.charCodeAt(pos);
   const c1 = str.charCodeAt(pos + 1);
   if (
@@ -14,9 +15,9 @@ export function lexOperator (str, pos) {
     // { } ! # % &
     c0 === 123 || c0 === 125 || c0 === 33 || c0 === 35 || c0 === 37 || c0 === 38 ||
     // ( ) * + , -
-    c0 === 40 || c0 === 41 || c0 === 42 || c0 === 43 || c0 === 44 || c0 === 45 ||
+    (c0 >= 40 && c0 <= 45) ||
     // / : ; < = >
-    c0 === 47 || c0 === 58 || c0 === 59 || c0 === 60 || c0 === 61 || c0 === 62 ||
+    c0 === 47 || (c0 >= 58 && c0 <= 62) ||
     // @ ^
     c0 === 64 || c0 === 94
   ) {