@borgar/fx 4.12.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.ts

@@ -0,0 +1,18 @@
+const PERIOD = 46;
+const COLON = 58;
+
+export function advRangeOp (str: string, pos: number): number {
+  const c0 = str.charCodeAt(pos);
+  if (c0 === PERIOD) {
+    const c1 = str.charCodeAt(pos + 1);
+    if (c1 === COLON) {
+      return str.charCodeAt(pos + 2) === PERIOD ? 3 : 2;
+    }
+  }
+  else if (c0 === COLON) {
+    const c1 = str.charCodeAt(pos + 1);
+    return c1 === PERIOD ? 2 : 1;
+  }
+  return 0;
+}
+

package/lib/lexers/canEndRange.ts

@@ -0,0 +1,25 @@
+// regular: [A-Za-z0-9_\u00a1-\uffff]
+export function canEndRange (str: string, pos: number): boolean {
+  const c = str.charCodeAt(pos);
+  return !(
+    (c >= 65 && c <= 90) || // A-Z
+    (c >= 97 && c <= 122) || // a-z
+    (c >= 48 && c <= 57) || // 0-9
+    (c === 95) || // _
+    (c > 0xA0) // \u00a1-\uffff
+  );
+}
+
+// partial: [A-Za-z0-9_($.]
+export function canEndPartialRange (str: string, pos: number): boolean {
+  const c = str.charCodeAt(pos);
+  return !(
+    (c >= 65 && c <= 90) || // A-Z
+    (c >= 97 && c <= 122) || // a-z
+    (c >= 48 && c <= 57) || // 0-9
+    (c === 95) || // _
+    (c === 40) || // (
+    (c === 36) || // $
+    (c === 46) // .
+  );
+}

package/lib/lexers/lexBoolean.ts

@@ -0,0 +1,55 @@
+import { BOOLEAN } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+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) {
+    const c1 = str.charCodeAt(pos + 1);
+    if (c1 === 82 || c1 === 114) {
+      const c2 = str.charCodeAt(pos + 2);
+      if (c2 === 85 || c2 === 117) {
+        const c3 = str.charCodeAt(pos + 3);
+        if (c3 === 69 || c3 === 101) {
+          const c4 = str.charCodeAt(pos + 4);
+          if (!preventMatch(c4)) {
+            return { type: BOOLEAN, value: str.slice(pos, pos + 4) };
+          }
+        }
+      }
+    }
+  }
+  // "false" (case insensitive)
+  if (c0 === 70 || c0 === 102) {
+    const c1 = str.charCodeAt(pos + 1);
+    if (c1 === 65 || c1 === 97) {
+      const c2 = str.charCodeAt(pos + 2);
+      if (c2 === 76 || c2 === 108) {
+        const c3 = str.charCodeAt(pos + 3);
+        if (c3 === 83 || c3 === 115) {
+          const c4 = str.charCodeAt(pos + 4);
+          if (c4 === 69 || c4 === 101) {
+            const c5 = str.charCodeAt(pos + 5);
+            if (!preventMatch(c5)) {
+              return { type: BOOLEAN, value: str.slice(pos, pos + 5) };
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/lib/lexers/lexContext.ts

@@ -0,0 +1,104 @@
+import { CONTEXT, CONTEXT_QUOTE } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+const QUOT_SINGLE = 39; // '
+const BR_OPEN = 91; // [
+const BR_CLOSE = 93; // ]
+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 lexContextQuoted (str: string, pos: number, options: { xlsx: boolean }): Token | undefined {
+  const c0 = str.charCodeAt(pos);
+  let br1: number;
+  let br2: number;
+  // quoted context: '(?:''|[^'])*('|$)(?=!)
+  if (c0 === QUOT_SINGLE) {
+    const start = pos;
+    pos++;
+    while (pos < str.length) {
+      const c = str.charCodeAt(pos);
+      if (c === BR_OPEN) {
+        if (br1) { return; } // only 1 allowed
+        br1 = pos;
+      }
+      else if (c === BR_CLOSE) {
+        if (br2) { return; } // only 1 allowed
+        br2 = pos;
+      }
+      else if (c === QUOT_SINGLE) {
+        pos++;
+        if (str.charCodeAt(pos) !== QUOT_SINGLE) {
+          let valid = br1 == null && br2 == null;
+          if (options.xlsx && (br1 === start + 1) && (br2 === pos - 2)) {
+            valid = true;
+          }
+          if ((br1 >= start + 1) && (br2 < pos - 2) && (br2 > br1 + 1)) {
+            valid = true;
+          }
+          if (valid && str.charCodeAt(pos) === EXCL) {
+            return { type: CONTEXT_QUOTE, value: str.slice(start, pos) };
+          }
+          return;
+        }
+      }
+      pos++;
+    }
+  }
+}
+
+// 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);
+      if (c === BR_OPEN) {
+        if (br1) { return; } // only 1 allowed
+        br1 = pos;
+      }
+      else if (c === BR_CLOSE) {
+        if (br2) { return; } // only 1 allowed
+        br2 = pos;
+      }
+      else if (c === EXCL) {
+        let valid = br1 == null && br2 == null;
+        if (options.xlsx && (br1 === start) && (br2 === pos - 1)) {
+          valid = true;
+        }
+        if ((br1 >= start) && (br2 < pos - 1) && (br2 > br1 + 1)) {
+          valid = true;
+        }
+        if (valid) {
+          return { type: CONTEXT, value: str.slice(start, pos) };
+        }
+      }
+      else if (
+        (br1 == null || br2 != null) &&
+        // [0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff]
+        !(
+          (c >= 65 && c <= 90) || // A-Z
+          (c >= 97 && c <= 122) || // a-z
+          (c >= 48 && c <= 57) || // 0-9
+          (c === 46) || // .
+          (c === 95) || // _
+          (c === 161) || // ¡
+          (c === 164) || // ¤
+          (c === 167) || // §
+          (c === 168) || // ¨
+          (c === 170) || // ª
+          (c === 173) || // \u00ad
+          (c >= 175)    // ¯-\uffff
+        )
+      ) {
+        return;
+      }
+      // 0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff
+      pos++;
+    }
+  }
+}

package/lib/lexers/lexError.ts

@@ -0,0 +1,15 @@
+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: string, pos: number): Token | undefined {
+  if (str.charCodeAt(pos) === HASH) {
+    re_ERROR.lastIndex = pos;
+    const m = re_ERROR.exec(str);
+    if (m) {
+      return { type: ERROR, value: m[0] };
+    }
+  }
+}

package/lib/lexers/lexFunction.ts

@@ -0,0 +1,37 @@
+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: string, pos: number): Token | undefined {
+  const start = pos;
+  // starts with: a-zA-Z_
+  let c = str.charCodeAt(pos);
+  if (
+    (c < 65 || c > 90) && // A-Z
+    (c < 97 || c > 122) && // a-z
+    (c !== 95) // _
+  ) {
+    return;
+  }
+  pos++;
+  // has any number of: a-zA-Z0-9_.
+  do {
+    c = str.charCodeAt(pos);
+    if (
+      (c < 65 || c > 90) && // A-Z
+      (c < 97 || c > 122) && // a-z
+      (c < 48 || c > 57) && // 0-9
+      (c !== 95) && // _
+      (c !== 46) // .
+    ) {
+      break;
+    }
+    pos++;
+  } while (pos < str.length);
+  // followed by a (
+  if (str.charCodeAt(pos) === PAREN_OPEN) {
+    return { type: FUNCTION, value: str.slice(start, pos) };
+  }
+}