@borgar/fx 4.3.1 → 4.5.0

package/lib/a1.js

@@ -5,6 +5,7 @@ import { stringifyPrefix, stringifyPrefixAlt } from './stringifyPrefix.js';
 const clamp = (min, val, max) => Math.min(Math.max(val, min), max);
 const toColStr = (c, a) => (a ? '$' : '') + toCol(c);
 const toRowStr = (r, a) => (a ? '$' : '') + toRow(r);
+const charFrom = String.fromCharCode;
 
 /**
  * Convert a column string representation to a 0 based
@@ -51,9 +52,13 @@ export function fromCol (columnString) {
  */
 export function toCol (columnIndex) {
   return (
-    (columnIndex >= 702 ? String.fromCharCode((((columnIndex - 702) / 676) - 0) % 26 + 65) : '') +
-    (columnIndex >= 26 ? String.fromCharCode(Math.floor(((columnIndex / 26) - 1) % 26 + 65)) : '') +
-    String.fromCharCode((columnIndex % 26 + 65))
+    (columnIndex >= 702
+      ? charFrom(((((columnIndex - 702) / 676) - 0) % 26) + 65)
+      : '') +
+    (columnIndex >= 26
+      ? charFrom(((((columnIndex / 26) - 1) % 26) + 65))
+      : '') +
+    charFrom((columnIndex % 26) + 65)
   );
 }
 
@@ -102,27 +107,31 @@ export function toA1 (range) {
     right = clamp(0, right | 0, MAX_COLS);
   }
   // A:A
-  if ((top === 0 && bottom >= MAX_ROWS) || (noTop && noBottom)) {
+  const allRows = top === 0 && bottom >= MAX_ROWS;
+  const haveAbsCol = ($left && !noLeft) || ($right && !noRight);
+  if ((allRows && !noLeft && !noRight && (!haveAbsCol || left === right)) || (noTop && noBottom)) {
     return toColStr(left, $left) + ':' + toColStr(right, $right);
   }
   // 1:1
-  else if ((left === 0 && right >= MAX_COLS) || (noLeft && noRight)) {
+  const allCols = left === 0 && right >= MAX_COLS;
+  const haveAbsRow = ($top && !noTop) || ($bottom && !noBottom);
+  if ((allCols && !noTop && !noBottom && (!haveAbsRow || top === bottom)) || (noLeft && noRight)) {
     return toRowStr(top, $top) + ':' + toRowStr(bottom, $bottom);
   }
   // A1:1
-  else if (!noLeft && !noTop && !noRight && noBottom) {
+  if (!noLeft && !noTop && !noRight && noBottom) {
     return toColStr(left, $left) + toRowStr(top, $top) + ':' + toColStr(right, $right);
   }
   // A:A1 => A1:1
-  else if (!noLeft && noTop && !noRight && !noBottom) {
+  if (!noLeft && noTop && !noRight && !noBottom) {
     return toColStr(left, $left) + toRowStr(bottom, $bottom) + ':' + toColStr(right, $right);
   }
   // A1:A
-  else if (!noLeft && !noTop && noRight && !noBottom) {
+  if (!noLeft && !noTop && noRight && !noBottom) {
     return toColStr(left, $left) + toRowStr(top, $top) + ':' + toRowStr(bottom, $bottom);
   }
   // A:A1 => A1:A
-  else if (noLeft && !noTop && !noRight && !noBottom) {
+  if (noLeft && !noTop && !noRight && !noBottom) {
     return toColStr(right, $right) + toRowStr(top, $top) + ':' + toRowStr(bottom, $bottom);
   }
   // A1:A1

package/lib/constants.js

@@ -25,5 +25,5 @@ export const CALL = 'CallExpression';
 export const ARRAY = 'ArrayExpression';
 export const IDENTIFIER = 'Identifier';
 
-export const MAX_COLS = 2 ** 14 - 1; // 16383
-export const MAX_ROWS = 2 ** 20 - 1; // 1048575
+export const MAX_COLS = (2 ** 14) - 1; // 16383
+export const MAX_ROWS = (2 ** 20) - 1; // 1048575

package/lib/lexer-srefs.spec.js

@@ -315,5 +315,10 @@ test('tokenize structured references (merges on)', t => {
     { type: FX_PREFIX, value: '=' },
     { type: REF_STRUCT, value: '\'Sales - May2020.xlsx\'!Table1[ [#Data], [#Totals], [Surf]:[Rod] ]' }
   ]);
+
+  t.isTokens('=[myworkbook.xlsx]Sheet1!TMP8w0habhr[#All]', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_STRUCT, value: '[myworkbook.xlsx]Sheet1!TMP8w0habhr[#All]' }
+  ]);
   t.end();
 });

package/lib/lexerParts.js

@@ -34,16 +34,17 @@ const re_CONTEXT_QUOTE = /^'(?:''|[^'])*('|$)(?=!)/;
 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 re_A1COL = new RegExp(`^${colPart}:${colPart}`, 'i');
-const re_A1ROW = new RegExp(`^${rowPart}:${rowPart}`, 'i');
-const re_A1RANGE = new RegExp(`^${rngPart}`, 'i');
+const nextNotChar = '(?![a-z0-9_\\u00a1-\\uffff])';
+const re_A1COL = new RegExp(`^${colPart}:${colPart}${nextNotChar}`, 'i');
+const re_A1ROW = new RegExp(`^${rowPart}:${rowPart}${nextNotChar}`, 'i');
+const re_A1RANGE = new RegExp(`^${rngPart}${nextNotChar}`, 'i');
 const re_A1PARTIAL = new RegExp(`^((${colPart}|${rowPart}):${rngPart}|${rngPart}:(${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}(:${cPart})?(?=\\W|$)`, 'i');
-const re_RCROW = new RegExp(`^${rPart}(:${rPart})?(?=\\W|$)`, 'i');
-const re_RCRANGE = new RegExp(`^(?:(?=[RC])${rPart}${cPart})`, 'i');
-const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(:${cPart}|:${rPart})(?![[\\d])|(${rPart}|${cPart})(:${rPart}${cPart}))(?=\\W|$)`, 'i');
+const re_RCCOL = new RegExp(`^${cPart}(:${cPart})?${nextNotChar}`, 'i');
+const re_RCROW = new RegExp(`^${rPart}(:${rPart})?${nextNotChar}`, 'i');
+const re_RCRANGE = new RegExp(`^(?:(?=[RC])${rPart}${cPart})${nextNotChar}`, 'i');
+const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(:${cPart}|:${rPart})(?![[\\d])|(${rPart}|${cPart})(:${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
@@ -51,7 +52,7 @@ const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(:${cPart}|:${rPart})(?![[\\d
 // 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 = /^(?![CR]\b)[a-zA-Z\\_\u00a1-\uffff][a-zA-Z0-9\\_.?\u00a1-\uffff]{0,254}/i;
+const re_NAMED = /^[a-zA-Z\\_\u00a1-\uffff][a-zA-Z0-9\\_.?\u00a1-\uffff]{0,254}/i;
 
 function makeHandler (type, re) {
   return str => {
@@ -62,6 +63,17 @@ function makeHandler (type, re) {
   };
 }
 
+function lexNamed (str) {
+  const m = re_NAMED.exec(str);
+  if (m) {
+    const lc = m[0].toLowerCase();
+    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) {
@@ -130,9 +142,9 @@ function lexRange (str, options) {
     if (t) {
       reRCNums.lastIndex = 0;
       while ((m = reRCNums.exec(t.value)) !== null) {
-        const x = (m[1] === 'R' ? MAX_ROWS : MAX_COLS) + (m[2] ? 1 : 0);
+        const x = (m[1] === 'R' ? MAX_ROWS : MAX_COLS) + (m[2] ? 0 : 1);
         const val = parseInt(m[3], 10);
-        if (val >= x || val <= -x) {
+        if (val > x || val < -x) {
           return null;
         }
       }
@@ -192,7 +204,7 @@ export const lexers = [
   lexRange,
   lexStructured,
   makeHandler(NUMBER, re_NUMBER),
-  makeHandler(REF_NAMED, re_NAMED)
+  lexNamed
 ];
 
 export const lexersRefs = [
@@ -200,5 +212,5 @@ export const lexersRefs = [
   lexContext,
   lexRange,
   lexStructured,
-  makeHandler(REF_NAMED, re_NAMED)
+  lexNamed
 ];

package/lib/parseRef.spec.js

@@ -21,40 +21,51 @@ test('splitPrefix', t => {
   testStr('[foo][bar][baz]', false, [
     { value: 'foo', braced: true },
     { value: 'bar', braced: true },
-    { value: 'baz', braced: true } ]);
+    { value: 'baz', braced: true }
+  ]);
   testStr('foo[bar][baz]', false, [
     { value: 'foo', braced: false },
     { value: 'bar', braced: true },
-    { value: 'baz', braced: true } ]);
+    { value: 'baz', braced: true }
+  ]);
   testStr('[foo]bar[baz]', false, [
     { value: 'foo', braced: true },
     { value: 'bar', braced: false },
-    { value: 'baz', braced: true } ]);
+    { value: 'baz', braced: true }
+  ]);
   testStr('[foo][bar]baz', false, [
     { value: 'foo', braced: true },
     { value: 'bar', braced: true },
-    { value: 'baz', braced: false } ]);
+    { value: 'baz', braced: false }
+  ]);
   testStr('foo[bar]baz', false, [
     { value: 'foo', braced: false },
     { value: 'bar', braced: true },
-    { value: 'baz', braced: false } ]);
+    { value: 'baz', braced: false }
+  ]);
   testStr('[foo]bar[baz]', false, [
     { value: 'foo', braced: true },
     { value: 'bar', braced: false },
-    { value: 'baz', braced: true } ]);
+    { value: 'baz', braced: true }
+  ]);
   testStr('[foo]bar', false, [
     { value: 'foo', braced: true },
-    { value: 'bar', braced: false } ]);
+    { value: 'bar', braced: false }
+  ]);
   testStr('foo[bar]', false, [
     { value: 'foo', braced: false },
-    { value: 'bar', braced: true } ]);
+    { value: 'bar', braced: true }
+  ]);
   testStr('[foo][bar]', false, [
     { value: 'foo', braced: true },
-    { value: 'bar', braced: true } ]);
+    { value: 'bar', braced: true }
+  ]);
   testStr('[foo]', false, [
-    { value: 'foo', braced: true } ]);
+    { value: 'foo', braced: true }
+  ]);
   testStr('foo', false, [
-    { value: 'foo', braced: false } ]);
+    { value: 'foo', braced: false }
+  ]);
 
   t.end();
 });

package/lib/parser.js

@@ -493,7 +493,7 @@ prefix('{', function () {
 export function parse (source, options) {
   if (typeof source === 'string') {
     tokens = tokenize(source, {
-      withLocation: true,
+      withLocation: false,
       ...options,
       mergeRefs: true
     });

package/lib/parser.spec.js

@@ -227,7 +227,8 @@ test('parse array literals', t => {
       [ { type: 'Literal', value: 1234, raw: '1234' } ],
       [ { type: 'CallExpression', callee: { type: 'Identifier', name: 'UNIQUE' }, arguments: [
         { type: 'ReferenceIdentifier', value: 'A:A' }
-      ] } ] ] },
+      ] } ]
+    ] },
     { permitArrayCalls: true });
   // permitArrayCalls can be nested
   t.isParsed('={SUM({1,2}),3}',
@@ -235,9 +236,11 @@ test('parse array literals', t => {
       [ { type: 'CallExpression', callee: { type: 'Identifier', name: 'SUM' }, arguments: [
         { type: 'ArrayExpression', elements: [ [
           { type: 'Literal', value: 1, raw: '1' },
-          { type: 'Literal', value: 2, raw: '2' } ] ] }
+          { type: 'Literal', value: 2, raw: '2' }
+        ] ] }
       ] },
-      { type: 'Literal', value: 3, raw: '3' } ] ] },
+      { type: 'Literal', value: 3, raw: '3' } ]
+    ] },
     { permitArrayCalls: true });
   t.end();
 });
@@ -259,7 +262,8 @@ test('parse function calls', t => {
     type: 'CallExpression', callee: { type: 'Identifier', name: 'FOO' },
     arguments: [
       { type: 'Literal', value: 1, raw: '1' },
-      { type: 'Literal', value: 2, raw: '2' } ]
+      { type: 'Literal', value: 2, raw: '2' }
+    ]
   });
   const args = Array(300).fill('1');
   t.isParsed(`=FOO(${args.join(',')})`, {
@@ -270,20 +274,24 @@ test('parse function calls', t => {
     type: 'CallExpression', callee: { type: 'Identifier', name: 'FOO' },
     arguments: [
       { type: 'ReferenceIdentifier', value: 'A1' },
-      { type: 'ReferenceIdentifier', value: 'B2' } ]
+      { type: 'ReferenceIdentifier', value: 'B2' }
+    ]
   });
   t.isParsed('=FOO((A1,B2))', {
     type: 'CallExpression', callee: { type: 'Identifier', name: 'FOO' },
     arguments: [
       { type: 'BinaryExpression', operator: ',', arguments: [
         { type: 'ReferenceIdentifier', value: 'A1' },
-        { type: 'ReferenceIdentifier', value: 'B2' } ] } ]
+        { type: 'ReferenceIdentifier', value: 'B2' }
+      ] }
+    ]
   });
   t.isParsed('=FOO(BAR())', {
     type: 'CallExpression', callee: { type: 'Identifier', name: 'FOO' },
     arguments: [
       { type: 'CallExpression', callee: { type: 'Identifier', name: 'BAR' },
-        arguments: [] } ]
+        arguments: [] }
+    ]
   });
   t.isParsed('=FOO(,)', {
     type: 'CallExpression', callee: { type: 'Identifier', name: 'FOO' },
@@ -479,8 +487,18 @@ test('parse unary operator @', t => {
 // parse binary operators
 // FIXME: add precedence & associativity tests (2+3*4)
 [
-  '+', '-', '^', '*', '/', '&',
-  '=', '<', '>', '<=', '>=', '<>'
+  '+',
+  '-',
+  '^',
+  '*',
+  '/',
+  '&',
+  '=',
+  '<',
+  '>',
+  '<=',
+  '>=',
+  '<>'
 ].forEach(op => {
   test('parse binary operator ' + op, t => {
     t.isParsed(`1${op}2`, {
@@ -496,8 +514,10 @@ test('parse unary operator @', t => {
         { type: 'BinaryExpression', operator: op,
           arguments: [
             { type: 'Literal', value: 1, raw: '1' },
-            { type: 'Literal', value: 2, raw: '2' } ] },
-        { type: 'Literal', value: 3, raw: '3' } ]
+            { type: 'Literal', value: 2, raw: '2' }
+          ] },
+        { type: 'Literal', value: 3, raw: '3' }
+      ]
     });
     t.isParsed(`"foo"${op}"bar"`, {
       type: 'BinaryExpression', operator: op,
@@ -518,10 +538,12 @@ test('parse unary operator @', t => {
       arguments: [
         { type: 'ArrayExpression', elements: [ [
           { type: 'Literal', value: 1, raw: '1' },
-          { type: 'Literal', value: 2, raw: '2' } ] ] },
+          { type: 'Literal', value: 2, raw: '2' }
+        ] ] },
         { type: 'ArrayExpression', elements: [ [
           { type: 'Literal', value: 3, raw: '3' },
-          { type: 'Literal', value: 4, raw: '4' } ] ] }
+          { type: 'Literal', value: 4, raw: '4' }
+        ] ] }
       ]
     });
     t.isParsed(`FOO()${op}BAR()`, {
@@ -552,22 +574,26 @@ test('parse unary operator @', t => {
       type: 'BinaryExpression', operator: op,
       arguments: [
         { type: 'ReferenceIdentifier', value: 'named1' },
-        { type: 'ReferenceIdentifier', value: 'named2' } ] });
+        { type: 'ReferenceIdentifier', value: 'named2' }
+      ] });
     t.isParsed(`A1${op}named2`, {
       type: 'BinaryExpression', operator: op,
       arguments: [
         { type: 'ReferenceIdentifier', value: 'A1' },
-        { type: 'ReferenceIdentifier', value: 'named2' } ] });
+        { type: 'ReferenceIdentifier', value: 'named2' }
+      ] });
     t.isParsed(`named1${op}B2`, {
       type: 'BinaryExpression', operator: op,
       arguments: [
         { type: 'ReferenceIdentifier', value: 'named1' },
-        { type: 'ReferenceIdentifier', value: 'B2' } ] });
+        { type: 'ReferenceIdentifier', value: 'B2' }
+      ] });
     t.isParsed(`(A1)${op}(B2)`, {
       type: 'BinaryExpression', operator: op,
       arguments: [
         { type: 'ReferenceIdentifier', value: 'A1' },
-        { type: 'ReferenceIdentifier', value: 'B2' } ] });
+        { type: 'ReferenceIdentifier', value: 'B2' }
+      ] });
     t.isInvalidExpr(`A1${op}0`);
     t.isInvalidExpr(`0${op}A1`);
     t.isInvalidExpr(`0${op}0`);
@@ -578,12 +604,14 @@ test('parse unary operator @', t => {
       type: 'BinaryExpression', operator: op,
       arguments: [
         { type: 'ReferenceIdentifier', value: 'A1' },
-        { type: 'ErrorLiteral', value: '#REF!', raw: '#REF!' } ] });
+        { type: 'ErrorLiteral', value: '#REF!', raw: '#REF!' }
+      ] });
     t.isParsed(`#REF!${op}B2`, {
       type: 'BinaryExpression', operator: op,
       arguments: [
         { type: 'ErrorLiteral', value: '#REF!', raw: '#REF!' },
-        { type: 'ReferenceIdentifier', value: 'B2' } ] });
+        { type: 'ReferenceIdentifier', value: 'B2' }
+      ] });
     t.isInvalidExpr(`A1${op}#NAME?`);
     t.isInvalidExpr(`A1${op}#VALUE!`);
     t.isInvalidExpr(`#NULL!${op}A1`);
@@ -595,8 +623,10 @@ test('parse unary operator @', t => {
         { type: 'BinaryExpression', operator: ',',
           arguments: [
             { type: 'ReferenceIdentifier', value: 'A1' },
-            { type: 'ReferenceIdentifier', value: 'B2' } ] },
-        { type: 'ReferenceIdentifier', value: 'C3' } ] });
+            { type: 'ReferenceIdentifier', value: 'B2' }
+          ] },
+        { type: 'ReferenceIdentifier', value: 'C3' }
+      ] });
     t.isParsed(`C3${op}(A1,B2)`, {
       type: 'BinaryExpression', operator: op,
       arguments: [
@@ -604,7 +634,8 @@ test('parse unary operator @', t => {
         { type: 'BinaryExpression', operator: ',',
           arguments: [
             { type: 'ReferenceIdentifier', value: 'A1' },
-            { type: 'ReferenceIdentifier', value: 'B2' } ] }
+            { type: 'ReferenceIdentifier', value: 'B2' }
+          ] }
       ] });
     // intersection ops
     t.isParsed(`(A1 B2)${op}C3`, {
@@ -613,8 +644,10 @@ test('parse unary operator @', t => {
         { type: 'BinaryExpression', operator: ' ',
           arguments: [
             { type: 'ReferenceIdentifier', value: 'A1' },
-            { type: 'ReferenceIdentifier', value: 'B2' } ] },
-        { type: 'ReferenceIdentifier', value: 'C3' } ] });
+            { type: 'ReferenceIdentifier', value: 'B2' }
+          ] },
+        { type: 'ReferenceIdentifier', value: 'C3' }
+      ] });
     t.isParsed(`C3${op}(A1 B2)`, {
       type: 'BinaryExpression', operator: op,
       arguments: [
@@ -622,7 +655,8 @@ test('parse unary operator @', t => {
         { type: 'BinaryExpression', operator: ' ',
           arguments: [
             { type: 'ReferenceIdentifier', value: 'A1' },
-            { type: 'ReferenceIdentifier', value: 'B2' } ] }
+            { type: 'ReferenceIdentifier', value: 'B2' }
+          ] }
       ] });
     // join ops
     t.isParsed(`(A1:(B2))${op}C3`, {
@@ -631,8 +665,10 @@ test('parse unary operator @', t => {
         { type: 'BinaryExpression', operator: ':',
           arguments: [
             { type: 'ReferenceIdentifier', value: 'A1' },
-            { type: 'ReferenceIdentifier', value: 'B2' } ] },
-        { type: 'ReferenceIdentifier', value: 'C3' } ] });
+            { type: 'ReferenceIdentifier', value: 'B2' }
+          ] },
+        { type: 'ReferenceIdentifier', value: 'C3' }
+      ] });
     t.isParsed(`C3${op}(A1:(B2))`, {
       type: 'BinaryExpression', operator: op,
       arguments: [
@@ -640,7 +676,8 @@ test('parse unary operator @', t => {
         { type: 'BinaryExpression', operator: ':',
           arguments: [
             { type: 'ReferenceIdentifier', value: 'A1' },
-            { type: 'ReferenceIdentifier', value: 'B2' } ] }
+            { type: 'ReferenceIdentifier', value: 'B2' }
+          ] }
       ] });
     // ref calls
     ([
@@ -743,33 +780,38 @@ test('position information is correct', t => {
   t.isParsed(
     '=-A1',
     { type: 'UnaryExpression', loc: [ 1, 4 ], operator: '-', arguments: [
-      { type: 'ReferenceIdentifier', value: 'A1', loc: [ 2, 4 ] } ] },
+      { type: 'ReferenceIdentifier', value: 'A1', loc: [ 2, 4 ] }
+    ] },
     { withLocation: true }
   );
   t.isParsed(
     '=10%',
     { type: 'UnaryExpression', loc: [ 1, 4 ], operator: '%', arguments: [
-      { type: 'Literal', value: 10, loc: [ 1, 3 ], raw: '10' } ] },
+      { type: 'Literal', value: 10, loc: [ 1, 3 ], raw: '10' }
+    ] },
     { withLocation: true }
   );
   t.isParsed(
     '=-(123)',
     { type: 'UnaryExpression', loc: [ 1, 6 ], operator: '-', arguments: [
-      { type: 'Literal', value: 123, loc: [ 3, 6 ], raw: '123' } ] },
+      { type: 'Literal', value: 123, loc: [ 3, 6 ], raw: '123' }
+    ] },
     { withLocation: true }
   );
   t.isParsed(
     '(123+(234))',
     { type: 'BinaryExpression', loc: [ 1, 9 ], operator: '+', arguments: [
       { type: 'Literal', value: 123, loc: [ 1, 4 ], raw: '123' },
-      { type: 'Literal', value: 234, loc: [ 6, 9 ], raw: '234' } ] },
+      { type: 'Literal', value: 234, loc: [ 6, 9 ], raw: '234' }
+    ] },
     { withLocation: true }
   );
   t.isParsed(
     '=(A1 B2)',
     { type: 'BinaryExpression', loc: [ 2, 7 ], operator: ' ', arguments: [
       { type: 'ReferenceIdentifier', value: 'A1', loc: [ 2, 4 ] },
-      { type: 'ReferenceIdentifier', value: 'B2', loc: [ 5, 7 ] } ] },
+      { type: 'ReferenceIdentifier', value: 'B2', loc: [ 5, 7 ] }
+    ] },
     { withLocation: true }
   );
   t.isParsed(
@@ -789,7 +831,8 @@ test('position information is correct', t => {
       [ { type: 'Literal', value: 1, loc: [ 3, 4 ], raw: '1' },
         { type: 'Literal', value: 2, loc: [ 6, 7 ], raw: '2' } ],
       [ { type: 'Literal', value: 3, loc: [ 9, 10 ], raw: '3' },
-        { type: 'Literal', value: 4, loc: [ 12, 13 ], raw: '4' } ] ] },
+        { type: 'Literal', value: 4, loc: [ 12, 13 ], raw: '4' } ]
+    ] },
     { withLocation: true }
   );
   t.end();
@@ -802,7 +845,9 @@ test('does not tolerate unterminated tokens', t => {
       arguments: [
         { type: 'ArrayExpression', elements: [
           [ { type: 'ReferenceIdentifier', value: 'A:A' },
-            { type: 'ReferenceIdentifier', value: 'B:B' } ] ] } ] },
+            { type: 'ReferenceIdentifier', value: 'B:B' } ]
+        ] }
+      ] },
     { permitArrayRanges: true });
   // whitespace in arguments
   t.isParsed('=A2:A5=XLOOKUP(B1,C:C, D:D)',
@@ -812,19 +857,23 @@ test('does not tolerate unterminated tokens', t => {
         arguments: [
           { type: 'ReferenceIdentifier', value: 'B1' },
           { type: 'ReferenceIdentifier', value: 'C:C' },
-          { type: 'ReferenceIdentifier', value: 'D:D' } ] } ] },
+          { type: 'ReferenceIdentifier', value: 'D:D' }
+        ] }
+    ] },
     { permitArrayRanges: true });
   // whitespace surrounding comma
   t.isParsed('=SUM(12 , B:B)',
     { type: 'CallExpression', callee: { type: 'Identifier', name: 'SUM' }, arguments: [
       { type: 'Literal', value: 12, raw: '12' },
-      { type: 'ReferenceIdentifier', value: 'B:B' } ] },
+      { type: 'ReferenceIdentifier', value: 'B:B' }
+    ] },
     { permitArrayCalls: true });
   // whitespace tailing operator
   t.isParsed('=A:A= C1',
     { type: 'BinaryExpression', operator: '=', arguments: [
       { type: 'ReferenceIdentifier', value: 'A:A' },
-      { type: 'ReferenceIdentifier', value: 'C1' } ] },
+      { type: 'ReferenceIdentifier', value: 'C1' }
+    ] },
     { permitArrayCalls: true });
   t.end();
 });
@@ -835,7 +884,9 @@ test('parser can permit xlsx mode references', t => {
     { type: 'CallExpression', callee: { type: 'Identifier', name: 'SUM' }, arguments: [
       { type: 'BinaryExpression', operator: '+', arguments: [
         { type: 'ReferenceIdentifier', value: '[Workbook.xlsx]!A1' },
-        { type: 'ReferenceIdentifier', value: '[Workbook.xlsx]!Table1[#Data]' } ] } ] },
+        { type: 'ReferenceIdentifier', value: '[Workbook.xlsx]!Table1[#Data]' }
+      ] }
+    ] },
     { xlsx: true });
   t.end();
 });

package/lib/rc.js

@@ -47,13 +47,15 @@ export function toR1C1 (range) {
     c1 = clamp($c1 ? 0 : -MAX_COLS, c1 | 0, MAX_COLS);
   }
   // C:C
-  if ((r0 === 0 && r1 >= MAX_ROWS) || (nullR0 && nullR1)) {
+  const allRows = r0 === 0 && r1 >= MAX_ROWS;
+  if ((allRows && !nullC0 && !nullC1) || (nullR0 && nullR1)) {
     const a = toCoord(c0, $c0);
     const b = toCoord(c1, $c1);
     return 'C' + (a === b ? a : a + ':C' + b);
   }
   // R:R
-  if ((c0 === 0 && c1 >= MAX_COLS) || (nullC0 && nullC1)) {
+  const allCols = c0 === 0 && c1 >= MAX_COLS;
+  if ((allCols && !nullR0 && !nullR1) || (nullC0 && nullC1)) {
     const a = toCoord(r0, $r0);
     const b = toCoord(r1, $r1);
     return 'R' + (a === b ? a : a + ':R' + b);

package/lib/sr.spec.js

@@ -88,6 +88,13 @@ test('parse structured references', t => {
     context: [ 'Sheet1' ]
   });
 
+  t.isSREqual('[myworkbook.xlsx]Sheet1!TMP8w0habhr[#All]', {
+    columns: [],
+    table: 'TMP8w0habhr',
+    context: [ 'myworkbook.xlsx', 'Sheet1' ],
+    sections: [ 'all' ]
+  });
+
   t.end();
 });
 

package/lib/translate-toA1.spec.js

@@ -100,7 +100,7 @@ test('translate partials from RC to A1', t => {
   t.end();
 });
 
-test('translate out of bounds coords from RC to A1', t => {
+test('translate bounds coords from RC to A1', t => {
   t.isR2A('=C[-1]', 'A1', '=XFD:XFD');
   t.isR2A('=C[-2]', 'A1', '=XFC:XFC');
   t.isR2A('=RC[16383]', 'B1', '=A1');
@@ -110,6 +110,10 @@ test('translate out of bounds coords from RC to A1', t => {
   t.isR2A('=R[1048575]C', 'A2', '=A1');
   t.isR2A('=R[1048575]C', 'A3', '=A2');
 
+  t.isR2A('=R1:R1048576', 'A1', '=$1:$1048576');
+  t.isR2A('=C1:C16384', 'A1', '=$A:$XFD');
+  t.isR2A('=R1C1:R1048576C16384', 'A1', '=$A$1:$XFD$1048576');
+
   const f1 = '=R[-1]C[-1]';
   t.is(translateToA1(f1, 'A1', { wrapEdges: false }), '=#REF!', f1);
 

package/lib/translate-toRC.spec.js

@@ -95,11 +95,14 @@ test('translate partials from A1 to RC', t => {
   t.end();
 });
 
-test('translate out of boundary coords from A1 to RC', t => {
+test('translate boundary coords from A1 to RC', t => {
   t.isA2R('=XFD:XFD', 'A1', '=C[16383]');
   t.isA2R('=A1', 'B1', '=RC[-1]');
   t.isA2R('=B1', 'C1', '=RC[-1]');
   t.isA2R('=1048576:1048576', 'A1', '=R[1048575]');
+  t.isA2R('=$1:$1048576', 'A1', '=R1:R1048576');
+  t.isA2R('=$A:$XFD', 'A1', '=C1:C16384');
+  t.isA2R('=$A$1:$XFD$1048576', 'A1', '=R1C1:R1048576C16384');
   t.isA2R('=A1', 'A2', '=R[-1]C');
   t.isA2R('=A2', 'A3', '=R[-1]C');
   t.end();