@borgar/fx 4.4.0 → 4.6.0

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

@@ -24,8 +24,8 @@ function toCoord (value, isAbs) {
  *
  * @private
  * @see parseR1C1Ref
- * @param {Object} range  A range object
- * @return {string}  An R1C1-style string represenation of a range
+ * @param {RangeR1C1} range  A range object
+ * @returns {string}  An R1C1-style string represenation of a range
  */
 export function toR1C1 (range) {
   let { r0, c0, r1, c1 } = range;
@@ -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);
@@ -132,11 +134,11 @@ function parseR1C1Part (ref) {
  * @private
  * @see parseA1Ref
  * @param {string} rangeString  A range string
- * @return {(Object|null)} An object representing a valid reference or null if it is invalid.
+ * @returns {(RangeR1C1|null)} An object representing a valid reference or null if it is invalid.
  */
-export function fromR1C1 (ref) {
+export function fromR1C1 (rangeString) {
   let final = null;
-  const [ part1, part2 ] = ref.split(':', 2);
+  const [ part1, part2 ] = rangeString.split(':', 2);
   const range = parseR1C1Part(part1);
   if (range) {
     const [ r0, c0, $r0, $c0 ] = range;
@@ -265,11 +267,11 @@ export function fromR1C1 (ref) {
  * ```
  *
  * @param {string} refString An R1C1-style reference string
- * @param {Object} [options={}]  Options
+ * @param {object} [options={}]  Options
  * @param {boolean} [options.allowNamed=true]  Enable parsing names as well as ranges.
  * @param {boolean} [options.allowTernary=false]  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.
  * @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 {(Object|null)} An object representing a valid reference or null if it is invalid.
+ * @returns {(ReferenceR1C1|null)} An object representing a valid reference or null if it is invalid.
  */
 export function parseR1C1Ref (refString, { allowNamed = true, allowTernary = false, xlsx = false } = {}) {
   const d = parseRef(refString, { allowNamed, allowTernary, xlsx, r1c1: true });
@@ -310,10 +312,10 @@ export function parseR1C1Ref (refString, { allowNamed = true, allowTernary = fal
  * // => 'Sheet1!R[9]C9:R[9]C9'
  * ```
  *
- * @param {Object} refObject A reference object
- * @param {Object} [options={}]  Options
+ * @param {ReferenceR1C1} refObject A reference object
+ * @param {object} [options={}]  Options
  * @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 {Object} The reference in R1C1-style string format
+ * @returns {string} The reference in R1C1-style string format
  */
 export function stringifyR1C1Ref (refObject, { xlsx = false } = {}) {
   const prefix = xlsx

package/lib/sr.js

@@ -185,16 +185,16 @@ export function parseSRange (raw) {
  *
  * @tutorial References.md
  * @param {string} ref  A structured reference string
- * @param {Object} [options={}]  Options
+ * @param {object} [options={}]  Options
  * @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 {(Object|null)} An object representing a valid reference or null if it is invalid.
+ * @returns {(ReferenceStruct|null)} An object representing a valid reference or null if it is invalid.
  */
-export function parseStructRef (ref, opts = { xlsx: false }) {
-  const r = parseRef(ref, opts);
+export function parseStructRef (ref, options = { xlsx: false }) {
+  const r = parseRef(ref, options);
   if (r && r.struct) {
     const structData = parseSRange(r.struct);
     if (structData && structData.length === r.struct.length) {
-      return opts.xlsx
+      return options.xlsx
         ? {
           workbookName: r.workbookName,
           sheetName: r.sheetName,
@@ -238,38 +238,38 @@ function toSentenceCase (str) {
  * // => 'workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]'
  * ```
  *
- * @param {Object} refObject A structured reference object
- * @param {Object} [options={}]  Options
+ * @param {ReferenceStruct} refObject A structured reference object
+ * @param {object} [options={}]  Options
  * @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 {Object} The structured reference in string format
+ * @returns {string} The structured reference in string format
  */
-export function stringifyStructRef (ref, { xlsx = false } = {}) {
+export function stringifyStructRef (refObject, { xlsx = false } = {}) {
   let s = xlsx
-    ? stringifyPrefixAlt(ref)
-    : stringifyPrefix(ref);
+    ? stringifyPrefixAlt(refObject)
+    : stringifyPrefix(refObject);
 
-  if (ref.table) {
-    s += ref.table;
+  if (refObject.table) {
+    s += refObject.table;
   }
-  const numColumns = ref.columns?.length ?? 0;
-  const numSections = ref.sections?.length ?? 0;
+  const numColumns = refObject.columns?.length ?? 0;
+  const numSections = refObject.sections?.length ?? 0;
   // single section
   if (numSections === 1 && !numColumns) {
-    s += `[#${toSentenceCase(ref.sections[0])}]`;
+    s += `[#${toSentenceCase(refObject.sections[0])}]`;
   }
   // single column
   else if (!numSections && numColumns === 1) {
-    s += `[${quoteColname(ref.columns[0])}]`;
+    s += `[${quoteColname(refObject.columns[0])}]`;
   }
   else {
     s += '[';
     // single [#this row] sections get normalized to an @
-    const singleAt = numSections === 1 && ref.sections[0].toLowerCase() === 'this row';
+    const singleAt = numSections === 1 && refObject.sections[0].toLowerCase() === 'this row';
     if (singleAt) {
       s += '@';
     }
     else if (numSections) {
-      s += ref.sections
+      s += refObject.sections
         .map(d => `[#${toSentenceCase(d)}]`)
         .join(',');
       if (numColumns) {
@@ -277,11 +277,11 @@ export function stringifyStructRef (ref, { xlsx = false } = {}) {
       }
     }
     // a case of a single alphanumberic column with a [#this row] becomes [@col]
-    if (singleAt && ref.columns.length === 1 && !needsBraces(ref.columns[0])) {
-      s += quoteColname(ref.columns[0]);
+    if (singleAt && refObject.columns.length === 1 && !needsBraces(refObject.columns[0])) {
+      s += quoteColname(refObject.columns[0]);
     }
     else if (numColumns) {
-      s += ref.columns.slice(0, 2)
+      s += refObject.columns.slice(0, 2)
         .map(d => (`[${quoteColname(d)}]`))
         .join(':');
     }

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();

package/lib/translate.js

@@ -30,22 +30,23 @@ const settings = {
  * // => "=SUM(RC[1],R2C5,Sheet!R3C5)");
  * ```
  *
- * @param {(string | Array<Object>)} formula A string (an Excel formula) or a token list that should be adjusted.
+ * @param {(string | Array<Token>)} formula A string (an Excel formula) or a token list that should be adjusted.
  * @param {string} anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
- * @param {Object} [options={}] The options
+ * @param {object} [options={}] The options
  * @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)
+ * @param {boolean} [options.allowTernary=true]  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.
+ * @returns {(string | Array<Token>)} A formula string or token list (depending on which was input)
  */
-export function translateToR1C1 (fx, anchorCell, { xlsx = false } = {}) {
+export function translateToR1C1 (formula, anchorCell, { xlsx = false, allowTernary = true } = {}) {
   const { top, left } = fromA1(anchorCell);
-  const isString = typeof fx === 'string';
+  const isString = typeof formula === 'string';
 
   const tokens = isString
-    ? tokenize(fx, { ...settings, xlsx })
-    : fx;
+    ? tokenize(formula, { ...settings, xlsx, allowTernary })
+    : formula;
 
   let offsetSkew = 0;
-  const refOpts = { xlsx, allowTernary: true };
+  const refOpts = { xlsx, allowTernary };
   tokens.forEach(token => {
     if (isRange(token)) {
       const tokenValue = token.value;
@@ -108,6 +109,7 @@ function toFixed (val, abs, base, max, wrapEdges = true) {
 const defaultOptions = {
   wrapEdges: true,
   mergeRefs: true,
+  allowTernary: true,
   xlsx: false
 };
 
@@ -142,13 +144,14 @@ const defaultOptions = {
  * `=Sheet3!#REF!:F3`. These are valid formulas in the Excel formula language
  * and Excel will accept them, but they are not supported in Google Sheets.
  *
- * @param {(string | Array<Object>)} formula A string (an Excel formula) or a token list that should be adjusted.
+ * @param {(string | Array<Token>)} formula A string (an Excel formula) or a token list that should be adjusted.
  * @param {string} anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
- * @param {Object} [options={}] The options
+ * @param {object} [options={}] The options
  * @param {boolean} [options.wrapEdges=true]  Wrap out-of-bounds ranges around sheet edges rather than turning them to #REF! errors
  * @param {boolean} [options.mergeRefs=true]   Should ranges be treated as whole references (`Sheet1!A1:B2`) or as separate tokens for each part: (`Sheet1`,`!`,`A1`,`:`,`B2`).
  * @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)
+ * @param {boolean} [options.allowTernary=true]  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.
+ * @returns {(string | Array<Token>)} A formula string or token list (depending on which was input)
  */
 export function translateToA1 (formula, anchorCell, options = defaultOptions) {
   const anchor = fromA1(anchorCell);
@@ -160,13 +163,13 @@ export function translateToA1 (formula, anchorCell, options = defaultOptions) {
       withLocation: false,
       mergeRefs: opts.mergeRefs,
       xlsx: opts.xlsx,
-      allowTernary: true,
+      allowTernary: opts.allowTernary,
       r1c1: true
     })
     : formula;
 
   let offsetSkew = 0;
-  const refOpts = { xlsx: opts.xlsx, allowTernary: true };
+  const refOpts = { xlsx: opts.xlsx, allowTernary: opts.allowTernary };
   tokens.forEach(token => {
     if (isRange(token)) {
       const tokenValue = token.value;

package/lib/translate.spec.js

@@ -0,0 +1,21 @@
+import { test, Test } from 'tape';
+import { translateToR1C1, translateToA1 } from './translate.js';
+
+Test.prototype.okayRoundTrip = function roundTrip (expr, anchor, options) {
+  const rc = translateToR1C1(expr, anchor, options);
+  const a1 = translateToA1(rc, anchor, options);
+  this.is(a1, expr, 'Round trip: ' + expr);
+};
+
+test('translate absolute cells from A1 to RC', t => {
+  t.okayRoundTrip('=Sheet1!$1:$1048576', 'A1');
+  t.okayRoundTrip('=D$1:$BJ$1048576', 'A1');
+  t.okayRoundTrip('=VLOOKUP(C7,Röðun,4,0)', 'A1');
+  t.okayRoundTrip('=COUNTIF(B$1442:B$1048576,$G1442)', 'A1');
+  t.okayRoundTrip('=IF(p2m<=D5,10,0)*scene_spend', 'A1');
+  t.okayRoundTrip('=(kwh_used_daily*kwhbtu*co2btu)/1000000', 'A1');
+  t.okayRoundTrip('=NOPLATT1+g1_+ROIC1+WACC+G1+g1_+G130+ROIC2+WACC+g2_+WACC+N', 'A1');
+  // FIXME: translate needs to be be able to specify allowTernary=false
+  t.okayRoundTrip('=foo:C3:D4', 'A1', { allowTernary: false });
+  t.end();
+});