@borgar/fx 4.12.0 → 5.0.0

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.ts

@@ -0,0 +1,60 @@
+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
+// U+00B0 with the range between U+00A0-U+00AF rather random:
+// /^[a-zA-Z\\_¡¤§¨ª\u00ad¯\u00b0-\uffff][a-zA-Z0-9\\_.?¡¤§¨ª\u00ad¯\u00b0-\uffff]{0,254}/
+//
+// 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: string, pos: number): Token | undefined {
+  const start = pos;
+  // starts with: [a-zA-Z\\_\u00a1-\uffff]
+  const s = str.charCodeAt(pos);
+  if (
+    (s >= 65 && s <= 90) || // A-Z
+    (s >= 97 && s <= 122) || // a-z
+    (s === 95) || // _
+    (s === 92) || // \
+    (s > 0xA0) // \u00a1-\uffff
+  ) {
+    pos++;
+  }
+  else {
+    return;
+  }
+  // has any number of: [a-zA-Z0-9\\_.?\u00a1-\uffff]
+  let c: number;
+  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 === 92) || // \
+      (c === 46) || // .
+      (c === 63) || // ?
+      (c > 0xA0) // \u00a1-\uffff
+    ) {
+      pos++;
+    }
+    else {
+      break;
+    }
+  } while (isFinite(c));
+
+  const len = pos - start;
+  if (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) };
+  }
+}

package/lib/lexers/lexNewLine.ts

@@ -0,0 +1,12 @@
+import { NEWLINE } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+export function lexNewLine (str: string, pos: number): Token | undefined {
+  const start = pos;
+  while (str.charCodeAt(pos) === 10) {
+    pos++;
+  }
+  if (pos !== start) {
+    return { type: NEWLINE, value: str.slice(start, pos) };
+  }
+}

package/lib/lexers/lexNumber.ts

@@ -0,0 +1,48 @@
+import { NUMBER } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+function advDigits (str: string, pos: number): number {
+  const start = pos;
+  do {
+    const c = str.charCodeAt(pos);
+    if (c < 48 || c > 57) { // 0-9
+      break;
+    }
+    pos++;
+  }
+  while (pos < str.length);
+  return pos - start;
+}
+
+// \d+(\.\d+)?(?:[eE][+-]?\d+)?
+export function lexNumber (str: string, pos: number): Token | undefined {
+  const start = pos;
+
+  // integer
+  const lead = advDigits(str, pos);
+  if (!lead) { return; }
+  pos += lead;
+
+  // optional fraction part
+  const c0 = str.charCodeAt(pos);
+  if (c0 === 46) { // .
+    pos++;
+    const frac = advDigits(str, pos);
+    if (!frac) { return; }
+    pos += frac;
+  }
+  // optional exponent part
+  const c1 = str.charCodeAt(pos);
+  if (c1 === 69 || c1 === 101) { // E e
+    pos++;
+    const sign = str.charCodeAt(pos);
+    if (sign === 43 || sign === 45) { // + -
+      pos++;
+    }
+    const exp = advDigits(str, pos);
+    if (!exp) { return; }
+    pos += exp;
+  }
+
+  return { type: NUMBER, value: str.slice(start, pos) };
+}

package/lib/lexers/lexOperator.ts

@@ -0,0 +1,26 @@
+import { OPERATOR } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+export function lexOperator (str: string, pos: number): Token | undefined {
+  const c0 = str.charCodeAt(pos);
+  const c1 = str.charCodeAt(pos + 1);
+  if (
+    (c0 === 60 && c1 === 61) || // <=
+    (c0 === 62 && c1 === 61) || // >=
+    (c0 === 60 && c1 === 62)    // <>
+  ) {
+    return { type: OPERATOR, value: str.slice(pos, pos + 2) };
+  }
+  if (
+    // { } ! # % &
+    c0 === 123 || c0 === 125 || c0 === 33 || c0 === 35 || c0 === 37 || c0 === 38 ||
+    // ( ) * + , -
+    (c0 >= 40 && c0 <= 45) ||
+    // / : ; < = >
+    c0 === 47 || (c0 >= 58 && c0 <= 62) ||
+    // @ ^
+    c0 === 64 || c0 === 94
+  ) {
+    return { type: OPERATOR, value: str[pos] };
+  }
+}

package/lib/lexers/lexRange.ts

@@ -0,0 +1,15 @@
+import type { Token } from '../types.ts';
+import { lexRangeA1 } from './lexRangeA1.ts';
+import { lexRangeR1C1 } from './lexRangeR1C1.ts';
+
+type LexRangeOptions = {
+  allowTernary: boolean,
+  mergeRefs: boolean,
+  r1c1: boolean
+};
+
+export function lexRange (str: string, pos: number, options: LexRangeOptions): Token | undefined {
+  return options.r1c1
+    ? lexRangeR1C1(str, pos, options)
+    : lexRangeA1(str, pos, options);
+}

package/lib/lexers/lexRangeA1.ts

@@ -0,0 +1,134 @@
+import { REF_RANGE, REF_BEAM, REF_TERNARY, MAX_COLS, MAX_ROWS } from '../constants.ts';
+import type { Token } from '../types.ts';
+import { advRangeOp } from './advRangeOp.ts';
+import { canEndRange, canEndPartialRange } from './canEndRange.ts';
+
+function advA1Col (str: string, pos: number): number {
+  // [A-Z]{1,3}
+  const start = pos;
+  if (str.charCodeAt(pos) === 36) { // $
+    pos++;
+  }
+  const stop = pos + 3;
+  let col = 0;
+  do {
+    const c = str.charCodeAt(pos);
+    if (c >= 65 && c <= 90) { // A-Z
+      col = 26 * col + c - 64;
+      pos++;
+    }
+    else if (c >= 97 && c <= 122) { // a-z
+      col = 26 * col + c - 96;
+      pos++;
+    }
+    else {
+      break;
+    }
+  }
+  while (pos < stop && pos < str.length);
+  return (col && col <= MAX_COLS + 1) ? pos - start : 0;
+}
+
+function advA1Row (str: string, pos: number): number {
+  // [1-9][0-9]{0,6}
+  const start = pos;
+  if (str.charCodeAt(pos) === 36) { // $
+    pos++;
+  }
+  const stop = pos + 7;
+  let row = 0;
+  let c = str.charCodeAt(pos);
+  if (c >= 49 && c <= 57) { // 1-9
+    row = row * 10 + c - 48;
+    pos++;
+    do {
+      c = str.charCodeAt(pos);
+      if (c >= 48 && c <= 57) { // 0-9
+        row = row * 10 + c - 48;
+        pos++;
+      }
+      else {
+        break;
+      }
+    }
+    while (pos < stop && pos < str.length);
+  }
+  return (row && row <= MAX_ROWS + 1) ? pos - start : 0;
+}
+
+export function lexRangeA1 (
+  str: string,
+  pos: number,
+  options: { mergeRefs: boolean, allowTernary: boolean }
+): Token | undefined {
+  let p = pos;
+  const left = advA1Col(str, p);
+  let right = 0;
+  let bottom = 0;
+  if (left) {
+    // TLBR: could be A1:A1
+    // TL R: could be A1:A (if allowTernary)
+    // TLB : could be A1:1 (if allowTernary)
+    //  LBR: could be A:A1 (if allowTernary)
+    //  L R: could be A:A
+    p += left;
+    const top = advA1Row(str, p);
+    p += top;
+    const op = advRangeOp(str, p);
+    const preOp = p;
+    if (op) {
+      p += op;
+      right = advA1Col(str, p);
+      p += right;
+      bottom = advA1Row(str, p);
+      p += bottom;
+      if (top && bottom && right) {
+        if (canEndRange(str, p) && options.mergeRefs) {
+          return { type: REF_RANGE, value: str.slice(pos, p) };
+        }
+      }
+      else if (!top && !bottom) {
+        if (canEndRange(str, p)) {
+          return { type: REF_BEAM, value: str.slice(pos, p) };
+        }
+      }
+      else if (options.allowTernary && (bottom || right)) {
+        if (canEndPartialRange(str, p)) {
+          return { type: REF_TERNARY, value: str.slice(pos, p) };
+        }
+      }
+    }
+    // LT  : this is A1
+    if (top && canEndRange(str, preOp)) {
+      return { type: REF_RANGE, value: str.slice(pos, preOp) };
+    }
+  }
+  else {
+    // T B : could be 1:1
+    // T BR: could be 1:A1 (if allowTernary)
+    const top = advA1Row(str, p);
+    if (top) {
+      p += top;
+      const op = advRangeOp(str, p);
+      if (op) {
+        p += op;
+        right = advA1Col(str, p);
+        if (right) {
+          p += right;
+        }
+        bottom = advA1Row(str, p);
+        p += bottom;
+        if (right && bottom && options.allowTernary) {
+          if (canEndPartialRange(str, p)) {
+            return { type: REF_TERNARY, value: str.slice(pos, p) };
+          }
+        }
+        if (!right && bottom) {
+          if (canEndRange(str, p)) {
+            return { type: REF_BEAM, value: str.slice(pos, p) };
+          }
+        }
+      }
+    }
+  }
+}

package/lib/lexers/lexRangeR1C1.ts

@@ -0,0 +1,146 @@
+import { REF_RANGE, REF_BEAM, REF_TERNARY, MAX_COLS, MAX_ROWS } from '../constants.ts';
+import type { Token } from '../types.ts';
+import { advRangeOp } from './advRangeOp.ts';
+import { canEndRange } from './canEndRange.ts';
+
+const BR_OPEN = 91; // [
+const BR_CLOSE = 93; // ]
+const UC_R = 82;
+const LC_R = 114;
+const UC_C = 67;
+const LC_C = 99;
+const PLUS = 43;
+const MINUS = 45;
+
+// C
+// C\[[+-]?\d+\]
+// C[1-9][0-9]{0,4}
+// R
+// R\[[+-]?\d+\]
+// R[1-9][0-9]{0,6}
+function lexR1C1Part (str: string, pos: number, isRow: boolean = false): number {
+  const start = pos;
+  const c0 = str.charCodeAt(pos);
+  if ((isRow ? c0 === UC_R || c0 === LC_R : c0 === UC_C || c0 === LC_C)) {
+    pos++;
+    let digits = 0;
+    let value = 0;
+    let stop = str.length;
+    const c1 = str.charCodeAt(pos);
+    let c;
+    let sign = 1;
+    const relative = c1 === BR_OPEN;
+    if (relative) {
+      stop = Math.min(stop, pos + (isRow ? 8 : 6));
+      pos++;
+      // allow +-
+      c = str.charCodeAt(pos);
+      if (c === PLUS || c === MINUS) {
+        pos++;
+        stop++;
+        sign = c === MINUS ? -1 : 1;
+      }
+    }
+    else if (c1 < 49 || c1 > 57 || isNaN(c1)) {
+      // char must be 1-9, or part is either just "R" or "C"
+      return 1;
+    }
+
+    do {
+      const c = str.charCodeAt(pos);
+      if (c >= 48 && c <= 57) { // 0-9
+        value = value * 10 + c - 48;
+        digits++;
+        pos++;
+      }
+      else {
+        break;
+      }
+    }
+    while (pos < stop);
+
+    const MAX = isRow ? MAX_ROWS : MAX_COLS;
+    if (relative) {
+      const c = str.charCodeAt(pos);
+      if (c !== BR_CLOSE) {
+        return 0;
+      }
+      // isRow: next char must not be a number!
+      pos++;
+      value *= sign;
+      return (digits && (-MAX <= value) && (value <= MAX))
+        ? pos - start
+        : 0;
+    }
+    // isRow: next char must not be a number!
+    return (digits && value <= (MAX + 1)) ? pos - start : 0;
+  }
+  return 0;
+}
+
+export function lexRangeR1C1 (
+  str: string,
+  pos: number,
+  options: { allowTernary: boolean }
+): Token | undefined {
+  let p = pos;
+  // C1
+  // C1:C1
+  // C1:R1C1  --partial
+  // R1
+  // R1:R1
+  // R1:R1C1  --partial
+  // R1C1
+  // R1C1:C1  --partial
+  // R1C1:R1  --partial
+  const r1 = lexR1C1Part(str, p, true);
+  p += r1;
+  const c1 = lexR1C1Part(str, p);
+  p += c1;
+  if (c1 || r1) {
+    const op = advRangeOp(str, p);
+    const preOp = p;
+    if (op) {
+      p += op;
+      const r2 = lexR1C1Part(str, p, true); // R1
+      p += r2;
+      const c2 = lexR1C1Part(str, p); // C1
+      p += c2;
+
+      // C1:R2C2  --partial
+      // R1:R2C2  --partial
+      // R1C1:C2  --partial
+      // R1C1:R2  --partial
+      if (
+        (r1 && !c1 && r2 && c2) ||
+        (!r1 && c1 && r2 && c2) ||
+        (r1 && c1 && r2 && !c2) ||
+        (r1 && c1 && !r2 && c2)
+      ) {
+        if (options.allowTernary && canEndRange(str, p)) {
+          return { type: REF_TERNARY, value: str.slice(pos, p) };
+        }
+      }
+      // C1:C2 -- beam
+      // R1:R2 -- beam
+      else if (
+        (c1 && c2 && !r1 && !r2) ||
+        (!c1 && !c2 && r1 && r2)
+      ) {
+        if (canEndRange(str, p)) {
+          return { type: REF_BEAM, value: str.slice(pos, p) };
+        }
+      }
+      // Note: we do not capture R1C1:R1C1, mergeRefTokens will join the parts
+    }
+    // R1
+    // C1
+    // R1C1
+    if (canEndRange(str, preOp)) {
+      return {
+        type: (r1 && c1) ? REF_RANGE : REF_BEAM,
+        value: str.slice(pos, preOp)
+      };
+    }
+  }
+}

package/lib/lexers/lexRangeTrim.ts

@@ -0,0 +1,26 @@
+import { OPERATOR_TRIM } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+const PERIOD = 46;
+const COLON = 58;
+
+export function lexRangeTrim (str: string, pos: number): Token | undefined {
+  const c0 = str.charCodeAt(pos);
+  if (c0 === PERIOD || c0 === COLON) {
+    const c1 = str.charCodeAt(pos + 1);
+    if (c0 !== c1) {
+      if (c1 === COLON) {
+        return {
+          type: OPERATOR_TRIM,
+          value: str.slice(pos, pos + (str.charCodeAt(pos + 2) === PERIOD ? 3 : 2))
+        };
+      }
+      else if (c1 === PERIOD) {
+        return {
+          type: OPERATOR_TRIM,
+          value: str.slice(pos, pos + 2)
+        };
+      }
+    }
+  }
+}

package/lib/lexers/lexRefOp.ts

@@ -0,0 +1,19 @@
+import { OPERATOR } from '../constants.ts';
+import type { Token } from '../types.ts';
+import { advRangeOp } from './advRangeOp.ts';
+
+const EXCL = 33; // !
+
+export function lexRefOp (str: string, pos: number, opts: { r1c1: boolean }): Token | undefined {
+  // in R1C1 mode we only allow [ '!' ]
+  if (str.charCodeAt(pos) === EXCL) {
+    return { type: OPERATOR, value: str[pos] };
+  }
+  if (!opts.r1c1) {
+    // in A1 mode we allow [ '!' ] + [ ':', '.:', ':.', '.:.']
+    const opLen = advRangeOp(str, pos);
+    if (opLen) {
+      return { type: OPERATOR, value: str.slice(pos, pos + opLen) };
+    }
+  }
+}

package/lib/lexers/lexString.ts

@@ -0,0 +1,22 @@
+import { STRING } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+const QUOT = 34;
+
+export function lexString (str: string, pos: number): Token | undefined {
+  const start = pos;
+  if (str.charCodeAt(pos) === QUOT) {
+    pos++;
+    while (pos < str.length) {
+      const c = str.charCodeAt(pos);
+      if (c === QUOT) {
+        pos++;
+        if (str.charCodeAt(pos) !== QUOT) {
+          return { type: STRING, value: str.slice(start, pos) };
+        }
+      }
+      pos++;
+    }
+    return { type: STRING, value: str.slice(start, pos), unterminated: true };
+  }
+}

package/lib/lexers/lexStructured.ts

@@ -0,0 +1,25 @@
+import { parseSRange } from '../parseSRange.ts';
+import { REF_STRUCT } from '../constants.ts';
+import { isWS } from './lexWhitespace.ts';
+import type { Token } from '../types.ts';
+
+const EXCL = 33; // !
+
+export function lexStructured (str: string, pos: number): Token | undefined {
+  const structData = parseSRange(str, pos);
+  if (structData && structData.length) {
+    // we have a match for a valid SR
+    let i = structData.length;
+    // skip tailing whitespace
+    while (isWS(str.charCodeAt(pos + i))) {
+      i++;
+    }
+    // and ensure that it isn't followed by a !
+    if (str.charCodeAt(pos + i) !== EXCL) {
+      return {
+        type: REF_STRUCT,
+        value: structData.token
+      };
+    }
+  }
+}

package/lib/lexers/lexWhitespace.ts

@@ -0,0 +1,31 @@
+import { WHITESPACE } from '../constants.ts';
+import type { Token } from '../types.ts';
+
+export function isWS (c) {
+  return (
+    c === 0x9 ||
+    c === 0xB ||
+    c === 0xC ||
+    c === 0xD ||
+    c === 0x20 ||
+    c === 0xA0 ||
+    c === 0x1680 ||
+    c === 0x2028 ||
+    c === 0x2029 ||
+    c === 0x202f ||
+    c === 0x205f ||
+    c === 0x3000 ||
+    c === 0xfeff ||
+    (c >= 0x2000 && c <= 0x200a)
+  );
+}
+
+export function lexWhitespace (str: string, pos: number): Token | undefined {
+  const start = pos;
+  while (isWS(str.charCodeAt(pos))) {
+    pos++;
+  }
+  if (pos !== start) {
+    return { type: WHITESPACE, value: str.slice(start, pos) };
+  }
+}