@borgar/fx 4.12.0 → 5.0.0

package/lib/tokenize.ts

@@ -0,0 +1,346 @@
+import {
+  FX_PREFIX,
+  NEWLINE,
+  NUMBER,
+  OPERATOR,
+  REF_NAMED,
+  UNKNOWN,
+  WHITESPACE,
+  FUNCTION,
+  OPERATOR_TRIM,
+  REF_RANGE
+} from './constants.ts';
+import { mergeRefTokens } from './mergeRefTokens.ts';
+import { lexers, type PartLexer } from './lexers/sets.ts';
+import type { Token } from './types.ts';
+
+const reLetLambda = /^l(?:ambda|et)$/i;
+const isType = (t: Token, type: string) => t && t.type === type;
+const isTextTokenType = (tokenType: string) => tokenType === REF_NAMED || tokenType === FUNCTION;
+
+const causesBinaryMinus = (token: Token) => {
+  return !isType(token, OPERATOR) || (
+    token.value === '%' ||
+    token.value === '}' ||
+    token.value === ')' ||
+    token.value === '#'
+  );
+};
+
+function fixRCNames (tokens: Token[]): Token[] {
+  let withinCall = 0;
+  let parenDepth = 0;
+  let lastToken: Token;
+  for (const token of tokens) {
+    if (token.type === OPERATOR) {
+      if (token.value === '(') {
+        parenDepth++;
+        if (lastToken.type === FUNCTION) {
+          if (reLetLambda.test(lastToken.value)) {
+            withinCall = parenDepth;
+          }
+        }
+      }
+      else if (token.value === ')') {
+        parenDepth--;
+        if (parenDepth < withinCall) {
+          withinCall = 0;
+        }
+      }
+    }
+    else if (withinCall && token.type === UNKNOWN && /^[rc]$/.test(token.value)) {
+      token.type = REF_NAMED;
+    }
+    lastToken = token;
+  }
+  return tokens;
+}
+
+type OptsGetTokens = {
+  withLocation?: boolean,
+  mergeRefs?: boolean,
+  negativeNumbers?: boolean
+  allowTernary?: boolean
+  r1c1?: boolean
+  xlsx?: boolean
+};
+
+export function getTokens (fx: string, tokenHandlers: PartLexer[], options: OptsGetTokens = {}) {
+  const {
+    withLocation = false,
+    mergeRefs = true,
+    negativeNumbers = true
+  } = options;
+  const opts = {
+    withLocation: withLocation,
+    mergeRefs: mergeRefs,
+    allowTernary: options.allowTernary ?? false,
+    negativeNumbers: negativeNumbers,
+    r1c1: options.r1c1 ?? false,
+    xlsx: options.xlsx ?? false
+  };
+
+  const tokens = [];
+  let pos = 0;
+  let letOrLambda = 0;
+  let unknownRC = 0;
+  const trimOps = [];
+
+  let tail0: Token; // last non-whitespace token
+  let tail1: Token; // penultimate non-whitespace token
+  let lastToken: Token; // last token
+  const pushToken = (token: Token) => {
+    let tokenType = token.type;
+    const isCurrUnknown = tokenType === UNKNOWN;
+    const isLastUnknown = lastToken && lastToken.type === UNKNOWN;
+    if (lastToken && (
+      (isCurrUnknown && isLastUnknown) ||
+      (isCurrUnknown && isTextTokenType(lastToken.type)) ||
+      (isLastUnknown && isTextTokenType(tokenType))
+    )) {
+      // UNKNOWN tokens "contaminate" sibling text tokens
+      lastToken.value += token.value;
+      lastToken.type = UNKNOWN;
+      if (withLocation) {
+        lastToken.loc[1] = token.loc[1];
+      }
+    }
+    else {
+      if (tokenType === OPERATOR_TRIM) {
+        trimOps.push(tokens.length);
+        tokenType = UNKNOWN;
+        token.type = UNKNOWN;
+      }
+      // push token as normally
+      tokens[tokens.length] = token;
+      lastToken = token;
+      if (tokenType !== WHITESPACE && tokenType !== NEWLINE) {
+        tail1 = tail0;
+        tail0 = token;
+      }
+    }
+  };
+
+  if (fx.startsWith('=')) {
+    const token: Token = { type: FX_PREFIX, value: '=' };
+    if (withLocation) {
+      token.loc = [ 0, 1 ];
+    }
+    pos++;
+    pushToken(token);
+  }
+
+  const numHandlers = tokenHandlers.length;
+  while (pos < fx.length) {
+    const startPos = pos;
+    let token;
+    for (let i = 0; i < numHandlers; i++) {
+      token = tokenHandlers[i](fx, pos, opts);
+      if (token) {
+        pos += token.value.length;
+        break;
+      }
+    }
+
+    if (!token) {
+      token = {
+        type: UNKNOWN,
+        value: fx[pos]
+      };
+      pos++;
+    }
+    if (withLocation) {
+      token.loc = [ startPos, pos ];
+    }
+
+    // make a note if we found a let/lambda call
+    if (lastToken && token.value === '(' && lastToken.type === FUNCTION) {
+      if (reLetLambda.test(lastToken.value)) {
+        letOrLambda++;
+      }
+    }
+    // make a note if we found a R or C unknown
+    if (token.type === UNKNOWN && token.value.length === 1) {
+      const valLC = token.value.toLowerCase();
+      unknownRC += (valLC === 'r' || valLC === 'c') ? 1 : 0;
+    }
+
+    if (negativeNumbers && token.type === NUMBER) {
+      const last1 = lastToken;
+      // do we have a number preceded by a minus?
+      if (last1?.type === OPERATOR && last1.value === '-') {
+        // missing tail1 means we are at the start of the stream
+        if (
+          !tail1 ||
+          tail1.type === FX_PREFIX ||
+          !causesBinaryMinus(tail1)
+        ) {
+          const minus = tokens.pop();
+          token.value = '-' + token.value;
+          if (token.loc) {
+            // ensure offsets are up to date
+            token.loc[0] = minus.loc[0];
+          }
+          // next step tries to counter the screwing around with the tailing
+          // it should be correct again once we pushToken()
+          tail0 = tail1;
+          lastToken = tokens[tokens.length - 1];
+        }
+      }
+    }
+
+    pushToken(token);
+  }
+
+  // if we encountered both a LAMBDA/LET call, and unknown 'r' or 'c' tokens
+  // we'll turn the unknown tokens into names within the call.
+  if (unknownRC && letOrLambda) {
+    fixRCNames(tokens);
+  }
+
+  // Any OPERATOR_TRIM tokens have been indexed already, they now need to be
+  // either turned into OPERATORs or UNKNOWNs. Trim operators are only allowed
+  // between two REF_RANGE tokens as they are not valid in expressions as full
+  // operators.
+  for (const index of trimOps) {
+    const before = tokens[index - 1];
+    const after = tokens[index + 1];
+    tokens[index].type = (before?.type === REF_RANGE && after?.type === REF_RANGE)
+      ? OPERATOR
+      : UNKNOWN;
+  }
+
+  if (mergeRefs) {
+    return mergeRefTokens(tokens);
+  }
+
+  return tokens;
+}
+
+/**
+ * Options for {@link tokenize}.
+ */
+export type OptsTokenize = {
+  /**
+   * Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
+   * @defaultValue true
+   */
+  withLocation?: boolean,
+  /**
+   * Should ranges be returned as whole references (`Sheet1!A1:B2`) or as separate tokens for each
+   * part: (`Sheet1`,`!`,`A1`,`:`,`B2`). This is the same as calling [`mergeRefTokens`](#mergeRefTokens)
+   * @defaultValue true
+   */
+  mergeRefs?: boolean,
+  /**
+   * Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1`
+   * (alternatively these will be unary operations in the tree).
+   * @defaultValue true
+   */
+  negativeNumbers?: boolean
+  /**
+   * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`. These are supported
+   * by Google Sheets but not Excel. See: [References.md](./References.md).
+   * @defaultValue false
+   */
+  allowTernary?: boolean
+  /**
+   * Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.
+   * @defaultValue false
+   */
+  r1c1?: boolean
+};
+
+/**
+ * Breaks a string formula into a list of tokens.
+ *
+ * The returned output will be an array of objects representing the tokens:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: FUNCTION, value: 'SUM' },
+ *   { type: OPERATOR, value: '(' },
+ *   { type: REF_RANGE, value: 'A1:B2' },
+ *   { type: OPERATOR, value: ')' }
+ * ]
+ * ```
+ *
+ * A collection of token types may be found as an object as the {@link tokenTypes}
+ * export on the package.
+ *
+ * _Warning:_ To support syntax highlighting as you type, `STRING` tokens are allowed to be
+ * "unterminated". For example, the incomplete formula `="Hello world` would be
+ * tokenized as:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: STRING, value: '"Hello world', unterminated: true },
+ * ]
+ * ```
+ *
+ * Parsers will need to handle this.
+ *
+ * @see {@link OptsTokenize}
+ * @see {@link tokenTypes}
+ * @param formula An Excel formula string (an Excel expression).
+ * @param [options]  Options
+ * @returns An array of Tokens
+ */
+export function tokenize (
+  formula: string,
+  options: OptsTokenize = {}
+): Token[] {
+  return getTokens(formula, lexers, options);
+}
+
+/**
+ * Breaks a string formula into a list of tokens.
+ *
+ * The returned output will be an array of objects representing the tokens:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: FUNCTION, value: 'SUM' },
+ *   { type: OPERATOR, value: '(' },
+ *   { type: REF_RANGE, value: 'A1:B2' },
+ *   { type: OPERATOR, value: ')' }
+ * ]
+ * ```
+ *
+ * A collection of token types may be found as an object as the {@link tokenTypes}
+ * export on the package.
+ *
+ * _Warning:_ To support syntax highlighting as you type, `STRING` tokens are allowed to be
+ * "unterminated". For example, the incomplete formula `="Hello world` would be
+ * tokenized as:
+ *
+ * ```js
+ * [
+ *   { type: FX_PREFIX, value: '=' },
+ *   { type: STRING, value: '"Hello world', unterminated: true },
+ * ]
+ * ```
+ *
+ * @see {@link OptsTokenize}
+ * @see {@link tokenTypes}
+ * @param formula An Excel formula string (an Excel expression).
+ * @param [options]  Options
+ * @returns An array of Tokens
+ */
+export function tokenizeXlsx (
+  formula: string,
+  options: OptsTokenize = {}
+): Token[] {
+  const opts = {
+    withLocation: options.withLocation ?? false,
+    mergeRefs: options.mergeRefs ?? true,
+    allowTernary: options.allowTernary ?? false,
+    negativeNumbers: options.negativeNumbers ?? true,
+    r1c1: options.r1c1 ?? false,
+    xlsx: true
+  };
+  return getTokens(formula, lexers, opts);
+}

package/lib/translate.spec.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect } from 'vitest';
+import { translateFormulaToR1C1 } from './translateToR1C1.ts';
+import { translateFormulaToA1 } from './translateToA1.ts';
+
+function okayRoundTrip (expr: string, anchor: string, options?: any) {
+  const rc = translateFormulaToR1C1(expr, anchor, options);
+  const a1 = translateFormulaToA1(rc, anchor, options);
+  expect(a1).toBe(expr);
+}
+
+describe('translate absolute cells from A1 to RC', () => {
+  test('sheet qualified ranges', () => {
+    okayRoundTrip('=Sheet1!$1:$1048576', 'A1');
+  });
+
+  test('mixed absolute ranges', () => {
+    okayRoundTrip('=D$1:$BJ$1048576', 'A1');
+  });
+
+  test('function calls with ranges', () => {
+    okayRoundTrip('=VLOOKUP(C7,Röðun,4,0)', 'A1');
+    okayRoundTrip('=COUNTIF(B$1442:B$1048576,$G1442)', 'A1');
+  });
+
+  test('complex expressions', () => {
+    okayRoundTrip('=IF(p2m<=D5,10,0)*scene_spend', 'A1');
+    okayRoundTrip('=(kwh_used_daily*kwhbtu*co2btu)/1000000', 'A1');
+    okayRoundTrip('=NOPLATT1+g1_+ROIC1+WACC+G1+g1_+G130+ROIC2+WACC+g2_+WACC+N', 'A1');
+  });
+
+  test('ternary ranges with allowTernary disabled', () => {
+    // FIXME: translate needs to be be able to specify allowTernary=false
+    okayRoundTrip('=foo:C3:D4', 'A1', { allowTernary: false });
+  });
+});

package/lib/translateToA1.spec.ts

@@ -0,0 +1,247 @@
+import { describe, test, expect } from 'vitest';
+import { translateFormulaToA1, translateTokensToA1 } from './translateToA1.ts';
+import { tokenize, tokenizeXlsx } from './tokenize.ts';
+import { addTokenMeta } from './addTokenMeta.ts';
+import { ERROR, FUNCTION, FX_PREFIX, OPERATOR, REF_RANGE, REF_BEAM, REF_STRUCT } from './constants.ts';
+
+function isR2A (expr: string, anchor: string, result: string, opts?: any) {
+  expect(translateFormulaToA1(expr, anchor, opts)).toBe(result);
+}
+
+describe('translate absolute cells from RC to A1', () => {
+  test('absolute cells with B2 anchor', () => {
+    isR2A('=R1C1', 'B2', '=$A$1');
+    isR2A('=R2C1', 'B2', '=$A$2');
+    isR2A('=R3C1', 'B2', '=$A$3');
+    isR2A('=R1C2', 'B2', '=$B$1');
+    isR2A('=R2C2', 'B2', '=$B$2');
+    isR2A('=R3C2', 'B2', '=$B$3');
+    isR2A('=R1C3', 'B2', '=$C$1');
+    isR2A('=R2C3', 'B2', '=$C$2');
+    isR2A('=R3C3', 'B2', '=$C$3');
+  });
+
+  test('absolute cells with Z19 anchor', () => {
+    // absolute cells, anchor has no real effect
+    isR2A('=R1C1', 'Z19', '=$A$1');
+    isR2A('=R2C1', 'Z19', '=$A$2');
+    isR2A('=R3C1', 'Z19', '=$A$3');
+    isR2A('=R1C2', 'Z19', '=$B$1');
+    isR2A('=R2C2', 'Z19', '=$B$2');
+    isR2A('=R3C2', 'Z19', '=$B$3');
+    isR2A('=R1C3', 'Z19', '=$C$1');
+    isR2A('=R2C3', 'Z19', '=$C$2');
+    isR2A('=R3C3', 'Z19', '=$C$3');
+  });
+});
+
+describe('translate relative cells from RC to A1', () => {
+  test('relative cells with B2 anchor', () => {
+    isR2A('=R[-1]C[-1]', 'B2', '=A1');
+    isR2A('=RC[-1]', 'B2', '=A2');
+    isR2A('=R[1]C[-1]', 'B2', '=A3');
+    isR2A('=R[-1]C', 'B2', '=B1');
+    isR2A('=RC', 'B2', '=B2');
+    isR2A('=R[1]C', 'B2', '=B3');
+    isR2A('=R[-1]C[1]', 'B2', '=C1');
+    isR2A('=RC[1]', 'B2', '=C2');
+    isR2A('=R[1]C[1]', 'B2', '=C3');
+  });
+
+  test('relative cells with I12 anchor', () => {
+    // relative cells move with anchor
+    isR2A('=R[-1]C[-1]', 'I12', '=H11');
+    isR2A('=RC[-1]', 'I12', '=H12');
+    isR2A('=R[1]C[-1]', 'I12', '=H13');
+    isR2A('=R[-1]C', 'I12', '=I11');
+    isR2A('=RC', 'I12', '=I12');
+    isR2A('=R[1]C', 'I12', '=I13');
+    isR2A('=R[-1]C[1]', 'I12', '=J11');
+    isR2A('=RC[1]', 'I12', '=J12');
+    isR2A('=R[1]C[1]', 'I12', '=J13');
+  });
+
+  test('relative cells with explicit [0] notation', () => {
+    isR2A('=R[0]C[-1]', 'B2', '=A2');
+    isR2A('=R[-1]C[0]', 'B2', '=B1');
+    isR2A('=R[0]C[0]', 'B2', '=B2');
+    isR2A('=R[1]C[0]', 'B2', '=B3');
+    isR2A('=R[0]C[1]', 'B2', '=C2');
+  });
+});
+
+describe('translate rows from RC to A1', () => {
+  test('relative and absolute row references', () => {
+    isR2A('=R', 'B2', '=2:2');
+    isR2A('=R[0]', 'B2', '=2:2');
+    isR2A('=R', 'B13', '=13:13');
+    isR2A('=R:R', 'B2', '=2:2');
+    isR2A('=R2:R2', 'B2', '=$2:$2');
+    isR2A('=R:R2', 'B2', '=2:$2');
+    isR2A('=R[1]:R[-1]', 'Z10', '=9:11');
+  });
+});
+
+describe('translate cols from RC to A1', () => {
+  test('relative and absolute column references', () => {
+    isR2A('=C', 'B2', '=B:B');
+    isR2A('=C[0]', 'B2', '=B:B');
+    isR2A('=C', 'Z2', '=Z:Z');
+    isR2A('=C:C', 'B2', '=B:B');
+    isR2A('=C2:C2', 'B2', '=$B:$B');
+    isR2A('=C:C2', 'B2', '=B:$B');
+    isR2A('=C[1]:C[-1]', 'M10', '=L:N');
+  });
+});
+
+describe('translate partials from RC to A1', () => {
+  test('partial range references', () => {
+    isR2A('=R[-5]C[-2]:C[-2]', 'C6', '=A1:A');
+    isR2A('=R[-5]C[-3]:R[-5]', 'D6', '=A1:1');
+    isR2A('=R[-6]C1:C1', 'C7', '=$A1:$A');
+    isR2A('=C1:R[-6]C1', 'D7', '=$A1:$A');
+    isR2A('=R[-6]C1:R[-6]', 'C7', '=$A1:1');
+    isR2A('=R[-6]:R[-6]C1', 'C7', '=$A1:1');
+    isR2A('=R1C[-2]:C[-2]', 'C6', '=A$1:A');
+    isR2A('=C[-2]:R1C[-2]', 'C6', '=A$1:A');
+    isR2A('=R1C[-3]:R1', 'D6', '=A$1:$1');
+    isR2A('=R1C1:C1', 'D6', '=$A$1:$A');
+    isR2A('=C1:R1C1', 'D6', '=$A$1:$A');
+    isR2A('=R1C1:R1', 'D6', '=$A$1:$1');
+    isR2A('=R1:R1C1', 'D6', '=$A$1:$1');
+  });
+});
+
+describe('translate bounds coords from RC to A1', () => {
+  test('boundary coordinate references', () => {
+    isR2A('=C[-1]', 'A1', '=XFD:XFD');
+    isR2A('=C[-2]', 'A1', '=XFC:XFC');
+    isR2A('=RC[16383]', 'B1', '=A1');
+    isR2A('=RC[16383]', 'C1', '=B1');
+    isR2A('=R[-1]', 'A1', '=1048576:1048576');
+    isR2A('=R[-2]', 'A1', '=1048575:1048575');
+    isR2A('=R[1048575]C', 'A2', '=A1');
+    isR2A('=R[1048575]C', 'A3', '=A2');
+
+    isR2A('=R1:R1048576', 'A1', '=$1:$1048576');
+    isR2A('=C1:C16384', 'A1', '=$A:$XFD');
+    isR2A('=R1C1:R1048576C16384', 'A1', '=$A$1:$XFD$1048576');
+  });
+
+  test('out of bounds references with wrapEdges disabled', () => {
+    const f1 = '=R[-1]C[-1]';
+    expect(translateFormulaToA1(f1, 'A1', { wrapEdges: false })).toBe('=#REF!');
+
+    const tokens = addTokenMeta(tokenize('SUM(Sheet1!R[-1]C[-1])', { r1c1: true, withLocation: true }));
+    expect(translateTokensToA1(tokens, 'A1', { wrapEdges: false })).toEqual([
+      { type: FUNCTION, value: 'SUM', loc: [ 0, 3 ], index: 0, depth: 0 },
+      { type: OPERATOR, value: '(', loc: [ 3, 4 ], index: 1, depth: 1, groupId: 'fxg1' },
+      { type: ERROR, value: '#REF!', loc: [ 4, 9 ], index: 2, depth: 1 },
+      { type: OPERATOR, value: ')', loc: [ 9, 10 ], index: 3, depth: 1, groupId: 'fxg1' }
+    ]);
+
+    const f2 = '=Sheet4!R[-2]C[-2]:R[-1]C[-1]';
+    expect(translateFormulaToA1(f2, 'B2', { wrapEdges: false })).toBe('=#REF!');
+
+    const f3 = '=Sheet4!R[-2]C[-2]:R[-1]C[-1]';
+    expect(translateFormulaToA1(f3, 'B2', { wrapEdges: false, mergeRefs: false })).toBe('=Sheet4!#REF!:A1');
+  });
+});
+
+describe('translate mixed rel/abs coords from RC to A1', () => {
+  test('mixed relative/absolute references', () => {
+    isR2A('=R1C[0]', 'B2', '=B$1');
+    isR2A('=R[4]C4', 'B4', '=$D8');
+    isR2A('=R[4]:R10', 'B4', '=8:$10');
+    isR2A('=C10:C[10]', 'B4', '=$J:L');
+    isR2A('=R1C1:R2C2', 'D4', '=$A$1:$B$2');
+    isR2A('=R[-1]C[-1]:R[2]C[2]', 'D4', '=C3:F6');
+  });
+});
+
+describe('translate involved formula from RC to A1', () => {
+  test('complex function expressions', () => {
+    isR2A('=SUM(IF(RC[1],R2C5,R3C5),Sheet1!R2*Sheet2!C[-2])', 'D10',
+      '=SUM(IF(E10,$E$2,$E$3),Sheet1!$2:$2*Sheet2!B:B)');
+  });
+});
+
+describe('translate works with merged ranges', () => {
+  test('preserves token metadata and locations', () => {
+    // This tests that:
+    // - Translate works with ranges that have context attached
+    // - If input is a tokenlist, output is also a tokenlist
+    // - If tokens have ranges, those ranges are adjusted to new token lengths
+    // - Properties added by addTokenMeta are preserved
+    const expr = '=SUM(IF(RC[1],R2C5,R3C5),Sheet1!R2*Sheet2!C[-2])';
+    const tokens = addTokenMeta(tokenize(expr, { withLocation: true, r1c1: true }));
+    const expected = [
+      { type: FX_PREFIX, value: '=', loc: [ 0, 1 ], index: 0, depth: 0 },
+      { type: FUNCTION, value: 'SUM', loc: [ 1, 4 ], index: 1, depth: 0 },
+      { type: OPERATOR, value: '(', loc: [ 4, 5 ], index: 2, depth: 1, groupId: 'fxg3' },
+      { type: FUNCTION, value: 'IF', loc: [ 5, 7 ], index: 3, depth: 1 },
+      { type: OPERATOR, value: '(', loc: [ 7, 8 ], index: 4, depth: 2, groupId: 'fxg1' },
+      { type: REF_RANGE, value: 'E10', loc: [ 8, 11 ], index: 5, depth: 2 },
+      { type: OPERATOR, value: ',', loc: [ 11, 12 ], index: 6, depth: 2 },
+      { type: REF_RANGE, value: '$E$2', loc: [ 12, 16 ], index: 7, depth: 2 },
+      { type: OPERATOR, value: ',', loc: [ 16, 17 ], index: 8, depth: 2 },
+      { type: REF_RANGE, value: '$E$3', loc: [ 17, 21 ], index: 9, depth: 2 },
+      { type: OPERATOR, value: ')', loc: [ 21, 22 ], index: 10, depth: 2, groupId: 'fxg1' },
+      { type: OPERATOR, value: ',', loc: [ 22, 23 ], index: 11, depth: 1 },
+      { type: REF_BEAM, value: 'Sheet1!$2:$2', loc: [ 23, 35 ], index: 12, depth: 1, groupId: 'fxg2' },
+      { type: OPERATOR, value: '*', loc: [ 35, 36 ], index: 13, depth: 1 },
+      { type: REF_BEAM, value: 'Sheet2!B:B', loc: [ 36, 46 ], index: 14, depth: 1 },
+      { type: OPERATOR, value: ')', loc: [ 46, 47 ], index: 15, depth: 1, groupId: 'fxg3' }
+    ];
+    expect(translateTokensToA1(tokens, 'D10')).toEqual(expected);
+  });
+});
+
+describe('translate works with xlsx mode references', () => {
+  function testExpr (expr: string, anchor: string, expected: any[], xlsx = true) {
+    const tokens = xlsx
+      ? tokenizeXlsx(expr, { mergeRefs: true, r1c1: true })
+      : tokenize(expr, { mergeRefs: true, r1c1: true });
+    expect(translateTokensToA1(tokens, anchor)).toEqual(expected);
+  }
+
+  test('XLSX workbook references', () => {
+    testExpr("'[My Fancy Workbook.xlsx]'!R1C", 'B2', [
+      { type: REF_RANGE, value: "'[My Fancy Workbook.xlsx]'!B$1" }
+    ]);
+
+    expect(translateTokensToA1([ { type: 'range', value: 'foo!R1C' } ], 'B2'))
+      .toEqual([ { type: 'range', value: 'foo!B$1' } ]);
+    expect(translateTokensToA1([ { type: 'range', value: '[foo]!R1C' } ], 'B2'))
+      .toEqual([ { type: 'range', value: '[foo]!B$1' } ]);
+    expect(translateTokensToA1([ { type: 'range', value: '[foo]bar!R1C' } ], 'B2'))
+      .toEqual([ { type: 'range', value: '[foo]bar!B$1' } ]);
+
+    testExpr('[Workbook.xlsx]!R1C', 'B2', [
+      { type: REF_RANGE, value: '[Workbook.xlsx]!B$1' }
+    ]);
+
+    testExpr('[Workbook.xlsx]Sheet1!R1C', 'B2', [
+      { type: REF_RANGE, value: '[Workbook.xlsx]Sheet1!B$1' }
+    ]);
+
+    testExpr('[Workbook.xlsx]!table[#data]', 'B2', [
+      { type: REF_STRUCT, value: '[Workbook.xlsx]!table[#data]' }
+    ]);
+  });
+});
+
+describe('translate works with trimmed ranges', () => {
+  function testExpr (expr: string, anchor: string, expected: any[]) {
+    const opts = { mergeRefs: true, r1c1: true };
+    expect(translateTokensToA1(tokenizeXlsx(expr, opts), anchor)).toEqual(expected);
+  }
+
+  test('trimmed range translation', () => {
+    testExpr('Sheet!R[-1]C[-1].:.RC*Sheet2!C[50].:.C[700]', 'B2', [
+      { type: 'range', value: 'Sheet!A1.:.B2' },
+      { type: 'operator', value: '*' },
+      { type: 'range_beam', value: 'Sheet2!AZ.:.ZZ' }
+    ]);
+  });
+});