@borgar/fx 4.1.0 → 4.3.0

package/lib/a1.spec.js

@@ -15,12 +15,21 @@ import { MAX_COLS, MAX_ROWS } from './constants.js';
 
 Test.prototype.isA1Equal = function isA1Equal (expr, expect, opts) {
   if (expect) {
-    expect = {
-      context: [],
-      name: '',
-      range: null,
-      ...expect
-    };
+    expect = opts?.xlsx
+      ? {
+        workbookName: '',
+        sheetName: '',
+        name: '',
+        range: null,
+        ...expect
+      }
+      : {
+        context: [],
+        name: '',
+        range: null,
+        ...expect
+      };
+    Object.assign(expect, expect);
     if (expect.range && typeof expect.range === 'object') {
       // mix in some defaults so we don't have to write things out in full
       expect.range = {
@@ -156,6 +165,108 @@ test('parse A1 references', t => {
   t.end();
 });
 
+test('parse A1 ranges in XLSX mode', t => {
+  const opts = { xlsx: true };
+
+  t.isA1Equal('[1]!A1', {
+    workbookName: '1',
+    sheetName: '',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal('[Workbook.xlsx]!A1', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal('[1]Sheet1!A1', {
+    workbookName: '1',
+    sheetName: 'Sheet1',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal('[Workbook.xlsx]Sheet1!A1', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal('[4]!name', {
+    workbookName: '4',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isA1Equal('[Workbook.xlsx]!name', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isA1Equal('[16]Sheet1!name', {
+    workbookName: '16',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.isA1Equal('[Workbook.xlsx]Sheet1!name', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.isA1Equal("='[1]'!A1", {
+    workbookName: '1',
+    sheetName: '',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal("='[Workbook.xlsx]'!A1", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal("'[1]Sheet1'!A1", {
+    workbookName: '1',
+    sheetName: 'Sheet1',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal("'[Workbook.xlsx]Sheet1'!A1", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    range: { top: 0, left: 0, bottom: 0, right: 0 }
+  }, opts);
+
+  t.isA1Equal("'[4]'!name", {
+    workbookName: '4',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isA1Equal("'[Workbook.xlsx]'!name", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isA1Equal("'[16]Sheet1'!name", {
+    workbookName: '16',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.isA1Equal("'[Workbook.xlsx]Sheet1'!name", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.end();
+});
+
 test('A1 partial ranges', t => {
   const opt = { allowTernary: true };
   // partials are not allowed by defult
@@ -252,6 +363,32 @@ test('stringifyA1Ref', t => {
   testRef({ context: [ 'My File.xlsx', 'Sheet1' ], name: 'foo' }, "'[My File.xlsx]Sheet1'!foo");
   testRef({ context: [ 'MyFile.xlsx' ], name: 'foo' }, 'MyFile.xlsx!foo');
   testRef({ context: [ 'My File.xlsx' ], name: 'foo' }, "'My File.xlsx'!foo");
+  // ignore .workbookName/.sheetName
+  testRef({ workbookName: 'MyFile.xlsx', sheetName: 'Sheet1', range: rangeA1 }, 'A1');
+  testRef({ workbookName: 'MyFile.xlsx', sheetName: 'Sheet1', name: 'foo' }, 'foo');
+  t.end();
+});
+
+test('stringifyA1Ref in XLSX mode', t => {
+  const rangeA1 = { top: 0, bottom: 0, left: 0, right: 0 };
+  const testRef = (ref, expect) => t.is(stringifyA1Ref(ref, { xlsx: true }), expect, expect);
+  testRef({ range: rangeA1 }, 'A1');
+  testRef({ sheetName: 'Sheet1', range: rangeA1 }, 'Sheet1!A1');
+  testRef({ sheetName: 'Sheet 1', range: rangeA1 }, "'Sheet 1'!A1");
+  testRef({ workbookName: 'MyFile.xlsx', sheetName: 'Sheet1', range: rangeA1 }, '[MyFile.xlsx]Sheet1!A1');
+  testRef({ workbookName: 'My File.xlsx', sheetName: 'Sheet1', range: rangeA1 }, "'[My File.xlsx]Sheet1'!A1");
+  testRef({ workbookName: 'MyFile.xlsx', range: rangeA1 }, '[MyFile.xlsx]!A1');
+  testRef({ workbookName: 'My File.xlsx', range: rangeA1 }, "'[My File.xlsx]'!A1");
+  testRef({ name: 'foo' }, 'foo');
+  testRef({ sheetName: 'Sheet1', name: 'foo' }, 'Sheet1!foo');
+  testRef({ sheetName: 'Sheet 1', name: 'foo' }, "'Sheet 1'!foo");
+  testRef({ workbookName: 'MyFile.xlsx', sheetName: 'Sheet1', name: 'foo' }, '[MyFile.xlsx]Sheet1!foo');
+  testRef({ workbookName: 'My File.xlsx', sheetName: 'Sheet1', name: 'foo' }, "'[My File.xlsx]Sheet1'!foo");
+  testRef({ workbookName: 'MyFile.xlsx', name: 'foo' }, '[MyFile.xlsx]!foo');
+  testRef({ workbookName: 'My File.xlsx', name: 'foo' }, "'[My File.xlsx]'!foo");
+  // ignore .context
+  testRef({ context: [ 'MyFile.xlsx', 'Sheet1' ], range: rangeA1 }, 'A1');
+  testRef({ context: [ 'MyFile.xlsx', 'Sheet1' ], name: 'foo' }, 'foo');
   t.end();
 });
 
@@ -268,4 +405,3 @@ test('A1 utilities', t => {
   t.deepEqual(toRelative(absA1Range), relA1Range, 'toRelative');
   t.end();
 });
-

package/lib/addTokenMeta.js

@@ -1,5 +1,6 @@
-import { REF_RANGE, REF_BEAM, REF_TERNARY, UNKNOWN } from './constants.js';
+import { REF_RANGE, REF_BEAM, REF_TERNARY, UNKNOWN, REF_STRUCT } from './constants.js';
 import { parseA1Ref } from './a1.js';
+import { parseStructRef } from './sr.js';
 
 function getIDer () {
   let i = 1;
@@ -13,6 +14,18 @@ function sameValue (a, b) {
   return a === b;
 }
 
+function sameArray (a, b) {
+  if ((Array.isArray(a) !== Array.isArray(b)) || a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (!sameValue(a[i], b[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function sameStr (a, b) {
   if (!a && !b) {
     return true;
@@ -25,6 +38,18 @@ function isEquivalent (refA, refB) {
   if ((refA.name || refB.name) && refA.name !== refB.name) {
     return false;
   }
+  // if structured
+  if ((refA.columns || refB.columns)) {
+    if (refA.table !== refB.table) {
+      return false;
+    }
+    if (!sameArray(refA.columns, refB.columns)) {
+      return false;
+    }
+    if (!sameArray(refA.sections, refB.sections)) {
+      return false;
+    }
+  }
   // if ranged, range must have the same dimensions (we don't care about $)
   if (refA.range || refB.range) {
     if (
@@ -46,6 +71,23 @@ function isEquivalent (refA, refB) {
   return true;
 }
 
+function addContext (ref, sheetName, workbookName) {
+  if (!ref.context.length) {
+    ref.context = [ workbookName, sheetName ];
+  }
+  else if (ref.context.length === 1) {
+    const scope = ref.context[0];
+    if (scope === sheetName || scope === workbookName) {
+      ref.context = [ workbookName, sheetName ];
+    }
+    else {
+      // a single scope on a non-named range is going to be a sheet name
+      ref.context = [ workbookName, scope ];
+    }
+  }
+  return ref;
+}
+
 /**
  * Runs through a list of tokens and adds extra attributes such as matching
  * parens and ranges.
@@ -140,23 +182,18 @@ export function addTokenMeta (tokens, { sheetName = '', workbookName = '' } = {}
       }
       arrayStart = null;
     }
-    else if (token.type === REF_RANGE || token.type === REF_BEAM || token.type === REF_TERNARY) {
-      const ref = parseA1Ref(token.value, { allowTernary: true });
-      if (ref && ref.range) {
+    else if (
+      token.type === REF_RANGE ||
+      token.type === REF_BEAM ||
+      token.type === REF_TERNARY ||
+      token.type === REF_STRUCT
+    ) {
+      const ref = (token.type === REF_STRUCT)
+        ? parseStructRef(token.value, { allowTernary: true })
+        : parseA1Ref(token.value, { allowTernary: true });
+      if (ref && (ref.range || ref.columns)) {
         ref.source = token.value;
-        if (!ref.context.length) {
-          ref.context = [ workbookName, sheetName ];
-        }
-        else if (ref.context.length === 1) {
-          const scope = ref.context[0];
-          if (scope === sheetName || scope === workbookName) {
-            ref.context = [ workbookName, sheetName ];
-          }
-          else {
-            // a single scope on a non-named range is going to be a sheet name
-            ref.context = [ workbookName, scope ];
-          }
-        }
+        addContext(ref, sheetName, workbookName);
         const known = knownRefs.find(d => isEquivalent(d, ref));
         if (known) {
           token.groupId = known.groupId;

package/lib/addTokenMeta.spec.js

@@ -1,5 +1,5 @@
 import { test, Test } from 'tape';
-import { FX_PREFIX, OPERATOR, NUMBER, REF_RANGE, REF_BEAM, FUNCTION, WHITESPACE } from './constants.js';
+import { FX_PREFIX, OPERATOR, NUMBER, REF_RANGE, REF_BEAM, FUNCTION, WHITESPACE, REF_STRUCT } from './constants.js';
 import { addTokenMeta } from './addTokenMeta.js';
 import { tokenize } from './lexer.js';
 
@@ -106,5 +106,14 @@ test('add extra meta to operators', t => {
     { index: 17, depth: 1, type: OPERATOR, value: ')', groupId: 'fxg3' }
   ], { sheetName: 'Sheet1', workbookName: 'foo' });
 
+  t.isMetaTokens('=table[#all]+table[foobar]+table[[#All]]', [
+    { index: 0, depth: 0, type: FX_PREFIX, value: '=' },
+    { index: 1, depth: 0, type: REF_STRUCT, value: 'table[#all]', groupId: 'fxg1' },
+    { index: 2, depth: 0, type: OPERATOR, value: '+' },
+    { index: 3, depth: 0, type: REF_STRUCT, value: 'table[foobar]', groupId: 'fxg2' },
+    { index: 4, depth: 0, type: OPERATOR, value: '+' },
+    { index: 5, depth: 0, type: REF_STRUCT, value: 'table[[#All]]', groupId: 'fxg1' }
+  ], { sheetName: 'Sheet1', workbookName: 'foo' });
+
   t.end();
 });

package/lib/fixRanges.js

@@ -4,14 +4,17 @@ import { parseStructRef, stringifyStructRef } from './sr.js';
 import { tokenize } from './lexer.js';
 import { REF_STRUCT } from './constants.js';
 
-// There is no R1C1 counerpart to this. This is because without an anchor cell
+// There is no R1C1 counterpart to this. This is because without an anchor cell
 // it is impossible to determine if a relative+absolute range (R[1]C[1]:R5C5)
 // needs to be flipped or not. The solution is to convert to A1 first:
 // translateToRC(fixRanges(translateToA1(...)))
 
 /**
- * Normalizes A1 style ranges in a formula or list of tokens so that the top and
- * left coordinates of the range are on the left-hand side of a colon operator:
+ * Normalizes A1 style ranges and structured references in a formula or list of
+ * tokens.
+ * 
+ * It ensures that that the top and left coordinates of an A1 range are on the
+ * left-hand side of a colon operator:
  *
  * `B2:A1` → `A1:B2`  
  * `1:A1` → `A1:1`  
@@ -31,13 +34,16 @@ import { REF_STRUCT } from './constants.js';
  * `B2:B` → `B2:1048576`  
  * `B2:2` → `B2:XFD2`  
  *
+ * Structured ranges are normalized cleaned up to have consistent order and
+ * capitalization of sections as well as removing redundant ones.
+ *
  * Returns the same formula with the ranges updated. If an array of tokens was
  * supplied, then a new array is returned.
  *
  * @param {(string | Array<Object>)} formula A string (an Excel formula) or a token list that should be adjusted.
  * @param {Object} [options={}]  Options
  * @param {boolean} [options.addBounds=false]  Fill in any undefined bounds of range objects. Top to 0, bottom to 1048575, left to 0, and right to 16383.
- * @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.xlsx=false]  Switches to the `[1]Sheet1!A1` or `[1]!name` prefix syntax form for external workbooks. See: [Prefixes.md](./Prefixes.md)
  * @return {(string | Array<Object>)} A formula string or token list (depending on which was input)
  */
 export function fixRanges (tokens, options = { addBounds: false }) {
@@ -49,7 +55,7 @@ export function fixRanges (tokens, options = { addBounds: false }) {
   if (!Array.isArray(tokens)) {
     throw new Error('fixRanges expects an array of tokens');
   }
-  const { addBounds, r1c1 } = options;
+  const { addBounds, r1c1, xlsx } = options;
   if (r1c1) {
     throw new Error('fixRanges does not have an R1C1 mode');
   }
@@ -61,18 +67,19 @@ export function fixRanges (tokens, options = { addBounds: false }) {
     }
     let offsetDelta = 0;
     if (token.type === REF_STRUCT) {
-      const newValue = stringifyStructRef(parseStructRef(token.value));
+      const sref = parseStructRef(token.value, { xlsx });
+      const newValue = stringifyStructRef(sref, { xlsx });
       offsetDelta = newValue.length - token.value.length;
       token.value = newValue;
     }
     else if (isRange(token)) {
-      const ref = parseA1Ref(token.value, { allowTernary: true });
+      const ref = parseA1Ref(token.value, { xlsx, allowTernary: true });
       const range = ref.range;
       // fill missing dimensions?
       if (addBounds) {
         addA1RangeBounds(range);
       }
-      const newValue = stringifyA1Ref(ref);
+      const newValue = stringifyA1Ref(ref, { xlsx });
       offsetDelta = newValue.length - token.value.length;
       token.value = newValue;
     }

package/lib/fixRanges.spec.js

@@ -138,3 +138,22 @@ test('fixRanges structured references', t => {
   t.isFixed('[ @foo bar ]', '[@[foo bar]]');
   t.end();
 });
+
+test('fixRanges works with xlsx mode', t => {
+  // should not mess with invalid ranges in normal mode
+  t.isFixed("='[Workbook]'!Table[Column]", "='[Workbook]'!Table[Column]");
+  t.isFixed('=[Workbook]!Table[Column]', '=[Workbook]!Table[Column]');
+  t.isFixed("='[Foo]'!A1", "='[Foo]'!A1");
+  t.isFixed('=[Foo]!A1', '=[Foo]!A1');
+  // should fix things in xlsx mode
+  const opts = { xlsx: true };
+  t.isFixed("='[Workbook]'!Table[Column]", '=[Workbook]!Table[Column]', opts);
+  t.isFixed('=[Workbook]!Table[Column]', '=[Workbook]!Table[Column]', opts);
+  t.isFixed('=[Lorem Ipsum]!Table[Column]', "='[Lorem Ipsum]'!Table[Column]", opts);
+  t.isFixed("='[Foo]'!A1", '=[Foo]!A1', opts);
+  t.isFixed('=[Foo]Bar!A1', '=[Foo]Bar!A1', opts);
+  t.isFixed('=[Foo Bar]Baz!A1', "='[Foo Bar]Baz'!A1", opts);
+  t.isFixed('=[Foo]!A1', '=[Foo]!A1', opts);
+  t.isFixed('=[Lorem Ipsum]!A1', "='[Lorem Ipsum]'!A1", opts);
+  t.end();
+});

package/lib/lexer-srefs.spec.js

@@ -2,7 +2,7 @@ import { test, Test } from 'tape';
 import {
   FX_PREFIX, UNKNOWN,
   OPERATOR, WHITESPACE,
-  REF_NAMED, CONTEXT_QUOTE, REF_STRUCT
+  REF_NAMED, CONTEXT_QUOTE, REF_STRUCT, REF_RANGE
 } from './constants.js';
 import { tokenize } from './lexer.js';
 
@@ -166,6 +166,14 @@ test('tokenize structured references (merges on)', t => {
   t.isTokens('[[#Totals],col name:Foo]', [
     { type: REF_STRUCT, value: '[[#Totals],col name:Foo]' }
   ]);
+  t.isTokens('Table1[[#This Row],[a]]*[1]Sheet1!$A$1', [
+    { type: REF_STRUCT, value: 'Table1[[#This Row],[a]]' },
+    { type: OPERATOR, value: '*' },
+    { type: REF_RANGE, value: '[1]Sheet1!$A$1' }
+  ], { xlsx: true });
+  t.isTokens("Sheet1!Table1[foo '[bar']]", [
+    { type: REF_STRUCT, value: "Sheet1!Table1[foo '[bar']]" }
+  ]);
   t.end();
 });
 

package/lib/lexer.js

@@ -202,6 +202,7 @@ export function getTokens (fx, tokenHandlers, options = {}) {
  * @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=true]  Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
  * @param {boolean} [options.mergeRefs=true]  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)
+ * @param {boolean} [options.xlsx=false]  Enables a `[1]Sheet1!A1` or `[1]!name` syntax form for external workbooks found only in XLSX files.
  * @return {Array<Object>} An AST of nodes
  */
 export function tokenize (formula, options = {}) {

package/lib/lexer.spec.js

@@ -1697,3 +1697,75 @@ test('tokenize partial ranges', t => {
 
   t.end();
 });
+
+test('tokenize external refs syntax from XLSX files', t => {
+  const opts = { xlsx: true };
+  // Excel XLS files only use positive integers as workbooks...
+  t.isTokens('=[1]!A1', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: '[1]!A1' }
+  ], opts);
+  t.isTokens('=[1]Sheet1!A1', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: '[1]Sheet1!A1' }
+  ], opts);
+  t.isTokens('=[4]!name', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: '[4]!name' }
+  ], opts);
+  t.isTokens('=[16]Sheet1!name', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: '[16]Sheet1!name' }
+  ], opts);
+  t.isTokens("='[1]'!A1", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: "'[1]'!A1" }
+  ], opts);
+  t.isTokens("='[1]Sheet1'!A1", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: "'[1]Sheet1'!A1" }
+  ], opts);
+  t.isTokens("='[4]'!name", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: "'[4]'!name" }
+  ], opts);
+  t.isTokens("='[16]Sheet1'!name", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: "'[16]Sheet1'!name" }
+  ], opts);
+  // ...fx additionally permits workbook names
+  t.isTokens('=[Workbook.xlsx]!A1', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: '[Workbook.xlsx]!A1' }
+  ], opts);
+  t.isTokens('=[Workbook.xlsx]Sheet1!A1', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: '[Workbook.xlsx]Sheet1!A1' }
+  ], opts);
+  t.isTokens('=[Workbook.xlsx]!name', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: '[Workbook.xlsx]!name' }
+  ], opts);
+  t.isTokens('=[Workbook.xlsx]Sheet1!name', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: '[Workbook.xlsx]Sheet1!name' }
+  ], opts);
+  t.isTokens("='[Workbook.xlsx]'!A1", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: "'[Workbook.xlsx]'!A1" }
+  ], opts);
+  t.isTokens("='[Workbook.xlsx]Sheet1'!A1", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: "'[Workbook.xlsx]Sheet1'!A1" }
+  ], opts);
+  t.isTokens("='[Workbook.xlsx]'!name", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: "'[Workbook.xlsx]'!name" }
+  ], opts);
+  t.isTokens("='[Workbook.xlsx]Sheet1'!name", [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_NAMED, value: "'[Workbook.xlsx]Sheet1'!name" }
+  ], opts);
+
+  t.end();
+});

package/lib/lexerParts.js

@@ -28,8 +28,7 @@ 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 = /^(?!!)(\[(?:[^\]])+\])?([0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff]+)?(?=!)/;
 const re_CONTEXT_QUOTE = /^'(?:''|[^'])*('|$)(?=!)/;
 
 const rngPart = '\\$?[A-Z]{1,3}\\$?[1-9][0-9]{0,6}';
@@ -63,6 +62,36 @@ function makeHandler (type, re) {
   };
 }
 
+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) {
@@ -159,8 +188,7 @@ export const lexers = [
   makeHandler(NEWLINE, re_NEWLINE),
   makeHandler(WHITESPACE, re_WHITESPACE),
   makeHandler(STRING, re_STRING),
-  makeHandler(CONTEXT_QUOTE, re_CONTEXT_QUOTE),
-  makeHandler(CONTEXT, re_CONTEXT),
+  lexContext,
   lexRange,
   lexStructured,
   makeHandler(NUMBER, re_NUMBER),
@@ -169,8 +197,7 @@ export const lexers = [
 
 export const lexersRefs = [
   lexRefOp,
-  makeHandler(CONTEXT_QUOTE, re_CONTEXT_QUOTE),
-  makeHandler(CONTEXT, re_CONTEXT),
+  lexContext,
   lexRange,
   lexStructured,
   makeHandler(REF_NAMED, re_NAMED)