@borgar/fx 4.11.2 → 4.13.0

package/lib/parseSRange.js

@@ -1,5 +1,14 @@
-const re_SRcolumnB = /^\[('['#@[\]]|[^'#@[\]])+\]/i;
-const re_SRcolumnN = /^([^#@[\]:]+)/i;
+/* eslint-disable no-multi-spaces */
+/* eslint-disable no-undefined */
+import { isWS } from './lexers/lexWhitespace.js';
+
+const AT = 64; // @
+const BR_CLOSE = 93; // ]
+const BR_OPEN = 91; // [
+const COLON = 58; // :
+const COMMA = 44; // ,
+const HASH = 35; // #
+const QUOT_SINGLE = 39; // '
 
 const keyTerms = {
   'headers': 1,
@@ -10,9 +19,8 @@ const keyTerms = {
   '@': 16
 };
 
-const fz = (...a) => Object.freeze(a);
-
 // only combinations allowed are: #data + (#headers | #totals | #data)
+const fz = (...a) => Object.freeze(a);
 const sectionMap = {
   // no terms
   0: fz(),
@@ -28,138 +36,200 @@ const sectionMap = {
   6: fz('data', 'totals')
 };
 
-const matchColumn = (s, allowUnbraced = true) => {
-  let m = re_SRcolumnB.exec(s);
-  if (m) {
-    const value = m[0].slice(1, -1).replace(/'(['#@[\]])/g, '$1');
-    return [ m[0], value ];
+function matchKeyword (str, pos) {
+  let p = pos;
+  if (str.charCodeAt(p++) !== BR_OPEN) {
+    return;
   }
-  if (allowUnbraced) {
-    m = re_SRcolumnN.exec(s);
-    if (m) {
-      return [ m[0], m[0] ];
+  if (str.charCodeAt(p++) !== HASH) {
+    return;
+  }
+  do {
+    const c = str.charCodeAt(p);
+    if (
+      (c >= 65 && c <= 90) || // A-Z
+      (c >= 97 && c <= 122) || // a-z
+      (c === 32) // space
+    ) {
+      p++;
+    }
+    else {
+      break;
     }
   }
-  return null;
-};
+  while (p < pos + 11); // max length: '[#this row'
+  if (str.charCodeAt(p++) !== BR_CLOSE) {
+    return;
+  }
+  return p - pos;
+}
 
-export function parseSRange (raw) {
-  const columns = [];
-  let pos = 0;
-  let s = raw;
-  let m;
-  let m1;
-  let terms = 0;
+function skipWhitespace (str, pos) {
+  let p = pos;
+  while (isWS(str.charCodeAt(p))) { p++; }
+  return p - pos;
+}
 
-  // start of structured ref?
-  if ((m = /^(\[\s*)/.exec(s))) {
-    // quickly determine if this is a simple keyword or column
-    // [#keyword]
-    if ((m1 = /^\[#([a-z ]+)\]/i.exec(s))) {
-      const k = m1[1].toLowerCase();
-      pos += m1[0].length;
-      if (keyTerms[k]) {
-        terms |= keyTerms[k];
-      }
-      else {
-        return null;
-      }
-    }
-    // [column]
-    else if ((m1 = matchColumn(s, false))) {
-      pos += m1[0].length;
-      columns.push(m1[1]);
-    }
-    // use the "normal" method
-    // [[#keyword]]
-    // [[column]]
-    // [@]
-    // [@column]
-    // [@[column]]
-    // [@column:column]
-    // [@column:[column]]
-    // [@[column]:column]
-    // [@[column]:[column]]
-    // [column:column]
-    // [column:[column]]
-    // [[column]:column]
-    // [[column]:[column]]
-    // [[#keyword],column]
-    // [[#keyword],column:column]
-    // [[#keyword],[#keyword],column:column]
-    // ...
-    else {
-      let expect_more = true;
-      s = s.slice(m[1].length);
-      pos += m[1].length;
-      // match keywords as we find them
-      while (
-        expect_more &&
-        (m = /^\[#([a-z ]+)\](\s*,\s*)?/i.exec(s))
-      ) {
-        const k = m[1].toLowerCase();
-        if (keyTerms[k]) {
-          terms |= keyTerms[k];
-          s = s.slice(m[0].length);
-          pos += m[0].length;
-          expect_more = !!m[2];
+function matchColumn (str, pos, allowUnbraced = true) {
+  let p = pos;
+  let column = '';
+  if (str.charCodeAt(p) === BR_OPEN) {
+    p++;
+    let c;
+    do {
+      c = str.charCodeAt(p);
+      if (c === QUOT_SINGLE) {
+        p++;
+        c = str.charCodeAt(p);
+        // Allowed set: '#@[]
+        if (c === QUOT_SINGLE || c === HASH || c === AT || c === BR_OPEN || c === BR_CLOSE) {
+          column += String.fromCharCode(c);
+          p++;
         }
         else {
-          return null;
+          return;
         }
       }
-      // is there an @ specifier?
-      if (expect_more && (m = /^@/.exec(s))) {
-        terms |= keyTerms['@'];
-        s = s.slice(1);
-        pos += 1;
-        expect_more = s[0] !== ']';
+      // Allowed set is all chars BUT: '#@[]
+      else if (c === QUOT_SINGLE || c === HASH || c === AT || c === BR_OPEN) {
+        return;
       }
-      // not all keyword terms may be combined
-      if (!(terms in sectionMap)) {
-        return null;
+      else if (c === BR_CLOSE) {
+        p++;
+        return [ str.slice(pos, p), column ];
       }
-      // column definitions
-      const leftCol = expect_more ? matchColumn(raw.slice(pos)) : null;
-      if (leftCol) {
-        pos += leftCol[0].length;
-        columns.push(leftCol[1]);
-        s = raw.slice(pos);
-        if (s[0] === ':') {
-          s = s.slice(1);
-          pos++;
-          const rightCol = matchColumn(s);
-          if (rightCol) {
-            pos += rightCol[0].length;
-            columns.push(rightCol[1]);
-          }
-          else {
-            return null;
-          }
-        }
-        expect_more = false;
+      else {
+        column += String.fromCharCode(c);
+        p++;
       }
-      // advance ws
-      while (raw[pos] === ' ') {
-        pos++;
+    }
+    while (p < str.length);
+  }
+  else if (allowUnbraced) {
+    let c;
+    do {
+      c = str.charCodeAt(p);
+      // Allowed set is all chars BUT: '#@[]:
+      if (c === QUOT_SINGLE || c === HASH || c === AT || c === BR_OPEN || c === BR_CLOSE || c === COLON) {
+        break;
       }
-      // close the ref
-      if (expect_more || raw[pos] !== ']') {
-        return null;
+      else {
+        column += String.fromCharCode(c);
+        p++;
       }
-      // step over the closing ]
-      pos++;
+    }
+    while (p < str.length);
+    if (p !== pos) {
+      return [ column, column ];
+    }
+  }
+}
+
+export function parseSRange (str, pos = 0) {
+  const columns = [];
+  const start = pos;
+  let m;
+  let terms = 0;
+
+  // structured refs start with a [
+  if (str.charCodeAt(pos) !== BR_OPEN) {
+    return;
+  }
+
+  // simple keyword: [#keyword]
+  if ((m = matchKeyword(str, pos))) {
+    const k = str.slice(pos + 2, pos + m - 1);
+    pos += m;
+    const term = keyTerms[k.toLowerCase()];
+    if (!term) { return; }
+    terms |= term;
+  }
+  // simple column: [column]
+  else if ((m = matchColumn(str, pos, false))) {
+    pos += m[0].length;
+    if (m[1]) {
+      columns.push(m[1]);
     }
   }
+  // use the "normal" method
+  // [[#keyword]]
+  // [[column]]
+  // [@]
+  // [@column]
+  // [@[column]]
+  // [@column:column]
+  // [@column:[column]]
+  // [@[column]:column]
+  // [@[column]:[column]]
+  // [column:column]
+  // [column:[column]]
+  // [[column]:column]
+  // [[column]:[column]]
+  // [[#keyword],column]
+  // [[#keyword],column:column]
+  // [[#keyword],[#keyword],column:column]
+  // ...
   else {
-    return null;
+    let expect_more = true;
+    pos++; // skip open brace
+    pos += skipWhitespace(str, pos);
+    // match keywords as we find them
+    while (expect_more && (m = matchKeyword(str, pos))) {
+      const k = str.slice(pos + 2, pos + m - 1);
+      const term = keyTerms[k.toLowerCase()];
+      if (!term) { return; }
+      terms |= term;
+      pos += m;
+      pos += skipWhitespace(str, pos);
+      expect_more = str.charCodeAt(pos) === COMMA;
+      if (expect_more) {
+        pos++;
+        pos += skipWhitespace(str, pos);
+      }
+    }
+    // is there an @ specifier?
+    if (expect_more && (str.charCodeAt(pos) === AT)) {
+      terms |= keyTerms['@'];
+      pos += 1;
+      expect_more = str.charCodeAt(pos) !== BR_CLOSE;
+    }
+    // not all keyword terms may be combined
+    if (!sectionMap[terms]) {
+      return;
+    }
+    // column definitions
+    const leftCol = expect_more && matchColumn(str, pos, true);
+    if (leftCol) {
+      pos += leftCol[0].length;
+      columns.push(leftCol[1]);
+      if (str.charCodeAt(pos) === COLON) {
+        pos++;
+        const rightCol = matchColumn(str, pos, true);
+        if (rightCol) {
+          pos += rightCol[0].length;
+          columns.push(rightCol[1]);
+        }
+        else {
+          return;
+        }
+      }
+      expect_more = false;
+    }
+    // advance ws
+    pos += skipWhitespace(str, pos);
+    // close the ref
+    if (expect_more || str.charCodeAt(pos) !== BR_CLOSE) {
+      return;
+    }
+    // step over the closing ]
+    pos++;
   }
 
   const sections = sectionMap[terms];
   return {
     columns,
     sections: sections ? sections.concat() : sections,
-    length: pos,
-    token: raw.slice(0, pos)
+    length: pos - start,
+    token: str.slice(start, pos)
   };
 }

package/lib/parseStructRef.spec.js

@@ -30,6 +30,10 @@ test('parse structured references', t => {
     columns: [ 'col' ]
   });
 
+  t.isSREqual('table[]', {
+    table: 'table'
+  });
+
   t.isSREqual('[#All]', {
     sections: [ 'all' ]
   });

package/lib/parser.js

@@ -63,8 +63,16 @@ const refFunctions = [
   'XLOOKUP'
 ];
 
+const symbolTable = {};
+let currentNode;
+let tokens;
+let tokenIndex;
+let permitArrayRanges = false;
+let permitArrayCalls = false;
+let looseRefCalls = false;
+
 const isReferenceFunctionName = fnName => {
-  return refFunctions.includes(fnName.toUpperCase());
+  return looseRefCalls || refFunctions.includes(fnName.toUpperCase());
 };
 
 const isReferenceToken = (token, allowOperators = false) => {
@@ -98,13 +106,6 @@ const isReferenceNode = node => {
   );
 };
 
-const symbolTable = {};
-let currentNode;
-let tokens;
-let tokenIndex;
-let permitArrayRanges = false;
-let permitArrayCalls = false;
-
 function halt (message, atIndex = null) {
   const err = new Error(message);
   err.source = tokens.map(d => d.value).join('');
@@ -688,6 +689,7 @@ prefix('{', function () {
  * @param {boolean} [options.negativeNumbers=true]  Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1` (alternatively these will be unary operations in the tree).
  * @param {boolean} [options.permitArrayRanges=false]  Ranges are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.
  * @param {boolean} [options.permitArrayCalls=false]  Function calls are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.
+ * @param {boolean} [options.looseRefCalls=false]  Permits any function call where otherwise only functions that return references would be permitted.
  * @param {boolean} [options.r1c1=false]  Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.
  * @param {boolean} [options.withLocation=false]  Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
  * @param {boolean} [options.xlsx=false]  Switches to the `[1]Sheet1!A1` or `[1]!name` prefix syntax form for external workbooks. See: [Prefixes.md](./Prefixes.md)
@@ -711,6 +713,8 @@ export function parse (formula, options) {
   permitArrayRanges = options?.permitArrayRanges;
   // allow calls in arrays "literals"?
   permitArrayCalls = options?.permitArrayCalls;
+  // allow any function call in range operations?
+  looseRefCalls = options?.looseRefCalls;
   // set index to start
   tokenIndex = 0;
   // discard redundant whitespace and = prefix

package/lib/parser.spec.js

@@ -1194,3 +1194,15 @@ test('parser whitespace handling', t => {
   });
   t.end();
 });
+
+test('looseRefCalls: true relaxes ref function restrictions', t => {
+  t.isInvalidExpr('A1:TESTFN()');
+  t.isParsed('A1:TESTFN()', {
+    type: 'BinaryExpression', operator: ':',
+    arguments: [
+      { type: 'ReferenceIdentifier', value: 'A1', kind: 'range' },
+      { type: 'CallExpression', callee: { type: 'Identifier', name: 'TESTFN' }, arguments: [] }
+    ]
+  }, { looseRefCalls: true });
+  t.end();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgar/fx",
-  "version": "4.11.2",
+  "version": "4.13.0",
   "description": "Utilities for working with Excel formulas",
   "main": "dist/fx.js",
   "types": "dist/fx.d.ts",
@@ -16,6 +16,7 @@
     "preversion": "npm test && npm run lint",
     "version": "npm run build",
     "lint": "eslint lib/*.js",
+    "benchmark": "node benchmark/benchmark.js",
     "test": "tape lib/*.spec.js | tap-min",
     "build:all": "npm run build:types && npm run build:docs && npm run build",
     "build:types": "jsdoc -c tsd.json lib>dist/fx.d.ts",
@@ -43,20 +44,21 @@
   "author": "Borgar Þorsteinsson <borgar@borgar.net> (http://borgar.net/)",
   "license": "MIT",
   "devDependencies": {
-    "@babel/core": "~7.23.9",
-    "@babel/eslint-parser": "~7.23.10",
-    "@babel/preset-env": "~7.23.9",
+    "@babel/core": "~7.28.5",
+    "@babel/eslint-parser": "~7.28.5",
+    "@babel/preset-env": "~7.28.5",
     "@borgar/eslint-config": "~3.1.0",
-    "@borgar/jsdoc-tsmd": "~0.2.1",
-    "@rollup/plugin-babel": "~6.0.4",
+    "@borgar/jsdoc-tsmd": "~0.2.2",
+    "@rollup/plugin-babel": "~6.1.0",
     "@rollup/plugin-terser": "~0.4.4",
     "babel-eslint": "~10.1.0",
+    "benchmark": "~2.1.4",
     "eslint": "~8.56.0",
     "eslint-plugin-jsdoc": "~48.1.0",
-    "jsdoc": "~4.0.2",
-    "rollup": "~4.12.0",
+    "jsdoc": "~4.0.5",
+    "rollup": "~4.52.5",
     "tap-min": "~3.0.0",
-    "tape": "~5.7.5",
-    "typescript": "~5.3.3"
+    "tape": "~5.9.0",
+    "typescript": "~5.9.3"
   }
 }

package/lib/lexerParts.js

@@ -1,228 +0,0 @@
-import {
-  OPERATOR,
-  BOOLEAN,
-  ERROR,
-  NUMBER,
-  FUNCTION,
-  NEWLINE,
-  WHITESPACE,
-  STRING,
-  CONTEXT,
-  CONTEXT_QUOTE,
-  REF_RANGE,
-  REF_BEAM,
-  REF_NAMED,
-  REF_TERNARY,
-  REF_STRUCT,
-  MAX_COLS,
-  MAX_ROWS,
-  OPERATOR_TRIM
-} from './constants.js';
-import { fromCol } from './fromCol.js';
-import { parseSRange } from './parseSRange.js';
-
-const re_ERROR = /^#(NAME\?|FIELD!|CALC!|VALUE!|REF!|DIV\/0!|NULL!|NUM!|N\/A|GETTING_DATA\b|SPILL!|UNKNOWN!|FIELD\b|CALC\b|SYNTAX\?|ERROR!|CONNECT!|BLOCKED!|EXTERNAL!)/i;
-const re_OPERATOR = /^(<=|>=|<>|[-+/*^%&<>=]|[{},;]|[()]|@|:|!|#)/;
-const re_BOOLEAN = /^(TRUE|FALSE)\b/i;
-const re_FUNCTION = /^[A-Z_]+[A-Z\d_.]*(?=\()/i;
-const re_NEWLINE = /^\n+/;
-const re_WHITESPACE = /^[ \f\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/;
-const re_STRING = /^"(?:""|[^"])*("|$)/;
-const re_NUMBER = /^(?:\d+(\.\d+)?(?:[eE][+-]?\d+)?|\d+)/;
-const re_CONTEXT = /^(?!!)(\[(?:[^\]])+\])?([0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff]+)?(?=!)/;
-const re_CONTEXT_QUOTE = /^'(?:''|[^'])*('|$)(?=!)/;
-const re_RANGE_TRIM = /^(\.:\.|\.:|:\.)/;
-
-const rngPart = '\\$?[A-Z]{1,3}\\$?[1-9][0-9]{0,6}';
-const colPart = '\\$?[A-Z]{1,3}';
-const rowPart = '\\$?[1-9][0-9]{0,6}';
-const rangeOp = '\\.?:\\.?';
-const nextNotChar = '(?![a-z0-9_\\u00a1-\\uffff])';
-const re_A1COL = new RegExp(`^${colPart}${rangeOp}${colPart}${nextNotChar}`, 'i');
-const re_A1ROW = new RegExp(`^${rowPart}${rangeOp}${rowPart}${nextNotChar}`, 'i');
-const re_A1RANGE = new RegExp(`^${rngPart}${nextNotChar}`, 'i');
-const re_A1PARTIAL = new RegExp(`^((${colPart}|${rowPart})${rangeOp}${rngPart}|${rngPart}${rangeOp}(${colPart}|${rowPart}))(?![\\w($.])`, 'i');
-const rPart = '(?:R(?:\\[[+-]?\\d+\\]|[1-9][0-9]{0,6})?)';
-const cPart = '(?:C(?:\\[[+-]?\\d+\\]|[1-9][0-9]{0,4})?)';
-const re_RCCOL = new RegExp(`^${cPart}(${rangeOp}${cPart})?${nextNotChar}`, 'i');
-const re_RCROW = new RegExp(`^${rPart}(${rangeOp}${rPart})?${nextNotChar}`, 'i');
-const re_RCRANGE = new RegExp(`^(?:(?=[RC])${rPart}${cPart})${nextNotChar}`, 'i');
-const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(${rangeOp}${cPart}|${rangeOp}${rPart})(?![[\\d])|(${rPart}|${cPart})(${rangeOp}${rPart}${cPart}))${nextNotChar}`, 'i');
-
-// 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
-// U+00B0 with the range between U+00A0-U+00AF rather random.
-// eslint-disable-next-line
-// const re_NAMED = /^[a-zA-Z\\_¡¤§¨ª\u00ad¯\u00b0-\uffff][a-zA-Z0-9\\_.?¡¤§¨ª\u00ad¯\u00b0-\uffff]{0,254}/i;
-// I've simplified to allowing everything above U+00A1:
-const re_NAMED = /^[a-zA-Z\\_\u00a1-\uffff][a-zA-Z0-9\\_.?\u00a1-\uffff]{0,254}/i;
-
-function makeHandler (type, re) {
-  return str => {
-    const m = re.exec(str);
-    if (m) {
-      return { type: type, value: m[0] };
-    }
-  };
-}
-
-function lexNamed (str) {
-  const m = re_NAMED.exec(str);
-  if (m) {
-    const lc = m[0].toLowerCase();
-    // names starting with \ must be at least 3 char long
-    if (lc[0] === '\\' && m[0].length < 3) {
-      return null;
-    }
-    // single characters R and C are forbidden as names
-    if (lc === 'r' || lc === 'c') {
-      return null;
-    }
-    return { type: REF_NAMED, value: m[0] };
-  }
-}
-
-const re_QUOTED_VALUE = /^'(?:[^[\]]+?)?(?:\[(.+?)\])?(?:[^[\]]+?)'$/;
-const re_QUOTED_VALUE_XLSX = /^'\[(.+?)\]'$/;
-function lexContext (str, options) {
-  const mq = re_CONTEXT_QUOTE.exec(str);
-  if (mq) {
-    const value = mq[0];
-    const isValid = options.xlsx
-      ? re_QUOTED_VALUE_XLSX.test(value) || re_QUOTED_VALUE.test(value)
-      : re_QUOTED_VALUE.test(value);
-    if (isValid) {
-      return { type: CONTEXT_QUOTE, value: value };
-    }
-  }
-  // 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
-  // We're only concerned with the non quoted version here as the quoted version
-  // doesn't currently examine what is in the quotes.
-  const m = re_CONTEXT.exec(str);
-  if (m) {
-    const [ , a, b ] = m;
-    const valid = (
-      ((a && b) || b) || // "[a]b!" or "b!" forms
-      (a && !b && options.xlsx) // "[a]" form (allowed in xlsx mode)
-    );
-    if (valid) {
-      return { type: CONTEXT, value: m[0] };
-    }
-  }
-}
-
-function lexStructured (str) {
-  const structData = parseSRange(str);
-  if (structData) {
-    // we have a match for a valid SR
-    let i = structData.length;
-    // skip tailing whitespace
-    while (str[i] === ' ') {
-      i++;
-    }
-    // and ensure that it isn't followed by a !
-    if (str[i] !== '!') {
-      return {
-        type: REF_STRUCT,
-        value: structData.token
-      };
-    }
-  }
-  return null;
-}
-
-const reRCNums = /([RC])(\[?)(-?\d+)/gi;
-const reA1Nums = /(\d+|[a-zA-Z]+)/gi;
-function lexRange (str, options) {
-  let m, t;
-  if (options.r1c1) {
-    // RC notation
-    if (options.allowTernary && (m = re_RCPARTIAL.exec(str))) {
-      t = { type: REF_TERNARY, value: m[0] };
-    }
-    else if ((m = re_RCRANGE.exec(str))) {
-      t = { type: REF_RANGE, value: m[0] };
-    }
-    else if ((m = re_RCROW.exec(str)) || (m = re_RCCOL.exec(str))) {
-      t = { type: REF_BEAM, value: m[0] };
-    }
-    if (t) {
-      reRCNums.lastIndex = 0;
-      while ((m = reRCNums.exec(t.value)) !== null) {
-        const x = (m[1] === 'R' ? MAX_ROWS : MAX_COLS) + (m[2] ? 0 : 1);
-        const val = parseInt(m[3], 10);
-        if (val > x || val < -x) {
-          return null;
-        }
-      }
-      return t;
-    }
-  }
-  else {
-    // A1 notation
-    if (options.allowTernary && (m = re_A1PARTIAL.exec(str))) {
-      t = { type: REF_TERNARY, value: m[0] };
-    }
-    else if ((m = re_A1COL.exec(str)) || (m = re_A1ROW.exec(str))) {
-      t = { type: REF_BEAM, value: m[0] };
-    }
-    else if ((m = re_A1RANGE.exec(str))) {
-      t = { type: REF_RANGE, value: m[0] };
-    }
-    if (t) {
-      reA1Nums.lastIndex = 0;
-      // XXX: can probably optimize this as we know letters can only be 3 at max
-      while ((m = reA1Nums.exec(t.value)) !== null) {
-        if (/^\d/.test(m[1])) { // row
-          if ((parseInt(m[1], 10) - 1) > MAX_ROWS) {
-            return null;
-          }
-        }
-        else if (fromCol(m[1]) > MAX_COLS) {
-          return null;
-        }
-      }
-      return t;
-    }
-  }
-}
-
-function lexRefOp (s, opts) {
-  // in R1C1 mode we only allow !
-  if (opts.r1c1) {
-    return (s[0] === '!')
-      ? { type: OPERATOR, value: s[0] }
-      : null;
-  }
-  // in A1 mode we allow [ '!', ':', '.:', ':.', '.:.']
-  const m = /^(!|\.?:\.?)/.exec(s);
-  if (m) {
-    return { type: OPERATOR, value: m[1] };
-  }
-  return null;
-}
-
-export const lexers = [
-  makeHandler(ERROR, re_ERROR),
-  makeHandler(OPERATOR_TRIM, re_RANGE_TRIM),
-  makeHandler(OPERATOR, re_OPERATOR),
-  makeHandler(FUNCTION, re_FUNCTION),
-  makeHandler(BOOLEAN, re_BOOLEAN),
-  makeHandler(NEWLINE, re_NEWLINE),
-  makeHandler(WHITESPACE, re_WHITESPACE),
-  makeHandler(STRING, re_STRING),
-  lexContext,
-  lexRange,
-  lexStructured,
-  makeHandler(NUMBER, re_NUMBER),
-  lexNamed
-];
-
-export const lexersRefs = [
-  lexRefOp,
-  lexContext,
-  lexRange,
-  lexStructured,
-  lexNamed
-];