@borgar/fx 5.0.0 → 5.0.2

package/lib/constants.ts

@@ -14,6 +14,9 @@ export const REF_BEAM = 'range_beam';
 export const REF_TERNARY = 'range_ternary';
 export const REF_NAMED = 'range_named';
 export const REF_STRUCT = 'structured';
+// TODO: in future, we should type the difference between A1:B1 (REF_RANGE) and
+//       A1 (REF_CELL) but this will require a major version bump.
+export const REF_CELL = 'cell'; // internal only
 export const FX_PREFIX = 'fx_prefix';
 export const UNKNOWN = 'unknown';
 

package/lib/fixRanges.spec.ts

@@ -66,6 +66,20 @@ describe('fixRanges basics', () => {
   });
 });
 
+describe('fixRanges prefixes', () => {
+  test('Quotes prefixes as needed', () => {
+    isFixed('=Sch1!B2', "='Sch1'!B2");
+    isFixed('=[Foo]Ab12x!B2', '=[Foo]Ab12x!B2');
+    isFixed('=[Foo]Ab12!B2', "='[Foo]Ab12'!B2");
+    isFixed('=ABC123!B2', "='ABC123'!B2");
+    isFixed('=abc123!B2', "='abc123'!B2");
+    isFixed('=C!B2', "='C'!B2");
+    isFixed('=R!B2', "='R'!B2");
+    isFixed('=RC!B2', "='RC'!B2");
+    isFixed('=CR!B2', '=CR!B2');
+  });
+});
+
 describe('fixRanges A1', () => {
   const opt = { allowTernary: true };
 

package/lib/isRCTokenValue.ts

@@ -0,0 +1,3 @@
+export function isRCTokenValue (value: string): boolean {
+  return value === 'r' || value === 'R' || value === 'c' || value === 'C';
+}

package/lib/lexers/lexRangeA1.ts

@@ -99,7 +99,7 @@ export function lexRangeA1 (
       }
     }
     // LT  : this is A1
-    if (top && canEndRange(str, preOp)) {
+    if (top && canEndRange(str, preOp) && str.charCodeAt(preOp) !== 33) { // 33 = "!"
       return { type: REF_RANGE, value: str.slice(pos, preOp) };
     }
   }

package/lib/lexers/lexRangeR1C1.ts

@@ -11,6 +11,7 @@ const UC_C = 67;
 const LC_C = 99;
 const PLUS = 43;
 const MINUS = 45;
+const EXCL = 33;
 
 // C
 // C\[[+-]?\d+\]
@@ -97,7 +98,7 @@ export function lexRangeR1C1 (
   p += r1;
   const c1 = lexR1C1Part(str, p);
   p += c1;
-  if (c1 || r1) {
+  if ((c1 || r1) && str.charCodeAt(p) !== EXCL) {
     const op = advRangeOp(str, p);
     const preOp = p;
     if (op) {

package/lib/mergeRefTokens.ts

@@ -1,27 +1,29 @@
-import { CONTEXT, CONTEXT_QUOTE, REF_RANGE, REF_NAMED, REF_BEAM, REF_TERNARY, OPERATOR, REF_STRUCT } from './constants.ts';
+import { CONTEXT, CONTEXT_QUOTE, REF_RANGE, REF_NAMED, REF_BEAM, REF_TERNARY, OPERATOR, REF_STRUCT, REF_CELL } from './constants.ts';
 import type { Token } from './types.ts';
 
 const END = '$';
 
 const validRunsMerge = [
-  [ REF_RANGE, ':', REF_RANGE ],
-  [ REF_RANGE, '.:', REF_RANGE ],
-  [ REF_RANGE, ':.', REF_RANGE ],
-  [ REF_RANGE, '.:.', REF_RANGE ],
+  [ REF_CELL, ':', REF_CELL ],
+  [ REF_CELL, '.:', REF_CELL ],
+  [ REF_CELL, ':.', REF_CELL ],
+  [ REF_CELL, '.:.', REF_CELL ],
   [ REF_RANGE ],
   [ REF_BEAM ],
   [ REF_TERNARY ],
-  [ CONTEXT, '!', REF_RANGE, ':', REF_RANGE ],
-  [ CONTEXT, '!', REF_RANGE, '.:', REF_RANGE ],
-  [ CONTEXT, '!', REF_RANGE, ':.', REF_RANGE ],
-  [ CONTEXT, '!', REF_RANGE, '.:.', REF_RANGE ],
+  [ CONTEXT, '!', REF_CELL, ':', REF_CELL ],
+  [ CONTEXT, '!', REF_CELL, '.:', REF_CELL ],
+  [ CONTEXT, '!', REF_CELL, ':.', REF_CELL ],
+  [ CONTEXT, '!', REF_CELL, '.:.', REF_CELL ],
+  [ CONTEXT, '!', REF_CELL ],
   [ CONTEXT, '!', REF_RANGE ],
   [ CONTEXT, '!', REF_BEAM ],
   [ CONTEXT, '!', REF_TERNARY ],
-  [ CONTEXT_QUOTE, '!', REF_RANGE, ':', REF_RANGE ],
-  [ CONTEXT_QUOTE, '!', REF_RANGE, '.:', REF_RANGE ],
-  [ CONTEXT_QUOTE, '!', REF_RANGE, ':.', REF_RANGE ],
-  [ CONTEXT_QUOTE, '!', REF_RANGE, '.:.', REF_RANGE ],
+  [ CONTEXT_QUOTE, '!', REF_CELL, ':', REF_CELL ],
+  [ CONTEXT_QUOTE, '!', REF_CELL, '.:', REF_CELL ],
+  [ CONTEXT_QUOTE, '!', REF_CELL, ':.', REF_CELL ],
+  [ CONTEXT_QUOTE, '!', REF_CELL, '.:.', REF_CELL ],
+  [ CONTEXT_QUOTE, '!', REF_CELL ],
   [ CONTEXT_QUOTE, '!', REF_RANGE ],
   [ CONTEXT_QUOTE, '!', REF_BEAM ],
   [ CONTEXT_QUOTE, '!', REF_TERNARY ],
@@ -62,7 +64,14 @@ const matcher = (tokens: Token[], currNode, anchorIndex, index = 0) => {
   while (i <= max) {
     const token = tokens[anchorIndex - i];
     if (token) {
-      const key = (token.type === OPERATOR) ? token.value : token.type;
+      const value = token.value;
+      let key = (token.type === OPERATOR) ? value : token.type;
+      // we need to prevent merging ["A1:B2" ":" "C3"] as a range is only
+      // allowed to contain a single ":" operator even if "A1:B2:C3" is
+      // valid Excel syntax
+      if (key === REF_RANGE && !value.includes(':')) {
+        key = REF_CELL;
+      }
       if (key in node) {
         node = node[key];
         i += 1;

package/lib/parseA1Ref.spec.ts

@@ -335,3 +335,10 @@ describe('A1 trimmed ranges vs named ranges', () => {
     isA1Equal('foo.:B2', { range: { top: 1, left: 1, right: 4460, trim: 'head' } }, { allowTernary: true });
   });
 });
+
+describe('Sheet name that looks like an A1 ref', () => {
+  test('parse correctly', () => {
+    isA1Equal("'Sch1'!B2", { context: [ 'Sch1' ], range: { top: 1, left: 1, bottom: 1, right: 1 } });
+    isA1Equal('Sch1!B2', { context: [ 'Sch1' ], range: { top: 1, left: 1, bottom: 1, right: 1 } });
+  });
+});

package/lib/stringifyA1Ref.spec.ts

@@ -30,6 +30,12 @@ describe('stringifyA1Ref', () => {
     // @ts-expect-error -- testing invalid input
     expect(stringifyA1Ref({ workbookName: 'MyFile.xlsx', sheetName: 'Sheet1', name: 'foo' })).toBe('foo');
   });
+
+  test('should quote prefixes that look like A1 ranges', () => {
+    expect(stringifyA1Ref({ context: [ 'Ab12' ], range: rangeA1 })).toBe("'Ab12'!A1");
+    expect(stringifyA1Ref({ context: [ 'Sch1' ], range: rangeA1 })).toBe("'Sch1'!A1");
+    expect(stringifyA1Ref({ context: [ 'Foo12345' ], range: rangeA1 })).toBe("'Foo12345'!A1");
+  });
 });
 
 describe('stringifyA1Ref in XLSX mode', () => {
@@ -61,4 +67,16 @@ describe('stringifyA1Ref in XLSX mode', () => {
     // @ts-expect-error -- testing invalid input
     expect(stringifyA1RefXlsx({ context: [ 'MyFile.xlsx', 'Sheet1' ], name: 'foo' })).toBe('foo');
   });
+
+  test('should quote prefixes that look like ranges', () => {
+    expect(stringifyA1RefXlsx({ sheetName: 'C', range: rangeA1 })).toBe("'C'!A1");
+    expect(stringifyA1RefXlsx({ sheetName: 'R', range: rangeA1 })).toBe("'R'!A1");
+    expect(stringifyA1RefXlsx({ sheetName: 'RC', range: rangeA1 })).toBe("'RC'!A1");
+    expect(stringifyA1RefXlsx({ sheetName: 'Ab12', range: rangeA1 })).toBe("'Ab12'!A1");
+    expect(stringifyA1RefXlsx({ sheetName: 'Sch1', range: rangeA1 })).toBe("'Sch1'!A1");
+    expect(stringifyA1RefXlsx({ sheetName: 'Foo12345', range: rangeA1 })).toBe("'Foo12345'!A1");
+    expect(stringifyA1RefXlsx({ workbookName: 'Ab12', range: rangeA1 })).toBe("'[Ab12]'!A1");
+    expect(stringifyA1RefXlsx({ workbookName: 'Sch1', range: rangeA1 })).toBe("'[Sch1]'!A1");
+    expect(stringifyA1RefXlsx({ workbookName: 'Foo12345', range: rangeA1 })).toBe("'[Foo12345]'!A1");
+  });
 });

package/lib/stringifyPrefix.ts

@@ -10,6 +10,27 @@ import type {
 } from './types.ts';
 
 const reBannedChars = /[^0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff]/;
+// A1-XFD1048575 | R | C | RC
+const reIsRangelike = /^(R|C|RC|[A-Z]{1,3}\d{1,7})$/i;
+
+export function needQuotes (scope: string, yesItDoes = 0): number {
+  if (yesItDoes) {
+    return 1;
+  }
+  if (scope) {
+    if (reBannedChars.test(scope)) {
+      return 1;
+    }
+    if (reIsRangelike.test(scope)) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+export function quotePrefix (prefix) {
+  return "'" + prefix.replace(/'/g, "''") + "'";
+}
 
 export function stringifyPrefix (
   ref: ReferenceA1 | ReferenceName | ReferenceStruct | ReferenceR1C1
@@ -23,12 +44,12 @@ export function stringifyPrefix (
     if (scope) {
       const part = (nth % 2) ? '[' + scope + ']' : scope;
       pre = part + pre;
-      quote += +reBannedChars.test(scope);
+      quote += needQuotes(scope, quote);
       nth++;
     }
   }
   if (quote) {
-    pre = "'" + pre.replace(/'/g, "''") + "'";
+    pre = quotePrefix(pre);
   }
   return pre ? pre + '!' : pre;
 }
@@ -41,14 +62,14 @@ export function stringifyPrefixXlsx (
   const { workbookName, sheetName } = ref;
   if (workbookName) {
     pre += '[' + workbookName + ']';
-    quote += +reBannedChars.test(workbookName);
+    quote += needQuotes(workbookName);
   }
   if (sheetName) {
     pre += sheetName;
-    quote += +reBannedChars.test(sheetName);
+    quote += needQuotes(sheetName);
   }
   if (quote) {
-    pre = "'" + pre.replace(/'/g, "''") + "'";
+    pre = quotePrefix(pre);
   }
   return pre ? pre + '!' : pre;
 }

package/lib/tokenize.spec.ts

@@ -1062,6 +1062,13 @@ describe('lexer', () => {
         { type: FX_PREFIX, value: '=' },
         { type: REF_RANGE, value: 'A1:C1' }
       ]);
+
+      isTokens('=A1:C1:D1', [
+        { type: FX_PREFIX, value: '=' },
+        { type: REF_RANGE, value: 'A1:C1' },
+        { type: OPERATOR, value: ':' },
+        { type: REF_RANGE, value: 'D1' }
+      ]);
     });
 
     test('spill range syntax', () => {
@@ -2100,4 +2107,96 @@ describe('lexer', () => {
     expect(tokenizeXlsx('[foo]!A1')).toEqual([ { type: REF_RANGE, value: '[foo]!A1' } ]);
     expect(tokenizeXlsx('foo!A1')).toEqual([ { type: REF_RANGE, value: 'foo!A1' } ]);
   });
+
+  test('r and c as LET arguments in R1C1 mode', () => {
+    // Unlike with LET(c,1,c) is not valid syntax with the R1C1 notation in Excel.
+    //
+    // If you create a cell with this expression in A1 mode and flip to R1C1, Excel
+    // will not change it when expressing it, but will not allow you to re-enter it.
+    //
+    // Excel will always save the formula such as the arguments will have a "_xlpm."
+    // prefix: _xlfn.LET(_xlpm.c,1,_xlpm.c)
+    //
+    // However, that is also invalid syntax in the exposed/common Excel formula syntax.
+    // To counter this, fx does the following:
+    //
+    // tokenize:
+    //    Supports _xlpm.c in both modes.
+    //    Assumes c, C, r and R are names when encountered as tokens within LET functions.
+    // translateTokensToR1C1:
+    //    Tries to be unabiguous by serializing "c" ranges in within LET as C[0].
+    //    Same goes for "r" to R[0]. Prefixed names are left as they are.
+    //    This way round-tripping is possible.
+    expect(tokenize('LET(c,1,c)', { r1c1: true })).toEqual([
+      { type: FUNCTION, value: 'LET' },
+      { type: OPERATOR, value: '(' },
+      { type: REF_NAMED, value: 'c' },
+      { type: OPERATOR, value: ',' },
+      { type: NUMBER, value: '1' },
+      { type: OPERATOR, value: ',' },
+      { type: REF_NAMED, value: 'c' },
+      { type: OPERATOR, value: ')' }
+    ]);
+    expect(tokenize('LET(r,1,r)', { r1c1: true })).toEqual([
+      { type: FUNCTION, value: 'LET' },
+      { type: OPERATOR, value: '(' },
+      { type: REF_NAMED, value: 'r' },
+      { type: OPERATOR, value: ',' },
+      { type: NUMBER, value: '1' },
+      { type: OPERATOR, value: ',' },
+      { type: REF_NAMED, value: 'r' },
+      { type: OPERATOR, value: ')' }
+    ]);
+    // Even if the second C could be identified as a range,
+    // which requires a parse-tree of some sort, the the "c+C"
+    // would both have to be names as arguments are
+    // case-insensitive:
+    expect(tokenize('LET(c,C,c+C)', { r1c1: true })).toEqual([
+      { type: FUNCTION, value: 'LET' },
+      { type: OPERATOR, value: '(' },
+      { type: REF_NAMED, value: 'c' },
+      { type: OPERATOR, value: ',' },
+      { type: REF_NAMED, value: 'C' }, // beam
+      { type: OPERATOR, value: ',' },
+      { type: REF_NAMED, value: 'c' },
+      { type: OPERATOR, value: '+' },
+      { type: REF_NAMED, value: 'C' }, // beam
+      { type: OPERATOR, value: ')' }
+    ]);
+    expect(tokenize('LET(c,C,SUM(c,C))', { r1c1: true })).toEqual([
+      { type: FUNCTION, value: 'LET' },
+      { type: OPERATOR, value: '(' },
+      { type: REF_NAMED, value: 'c' },
+      { type: OPERATOR, value: ',' },
+      { type: REF_NAMED, value: 'C' },
+      { type: OPERATOR, value: ',' },
+      { type: FUNCTION, value: 'SUM' },
+      { type: OPERATOR, value: '(' },
+      { type: REF_NAMED, value: 'c' },
+      { type: OPERATOR, value: ',' },
+      { type: REF_NAMED, value: 'C' },
+      { type: OPERATOR, value: ')' },
+      { type: OPERATOR, value: ')' }
+    ]);
+  });
+
+  describe('Sheet name that looks like an A1 ref', () => {
+    test('Sheet name that looks like an A1 ref', () => {
+      expect(tokenize("'Sch1'!B2")).toEqual([
+        { type: REF_RANGE, value: "'Sch1'!B2" }
+      ]);
+      expect(tokenize('Sch1!B2')).toEqual([
+        { type: REF_RANGE, value: 'Sch1!B2' }
+      ]);
+    });
+
+    test('Sheet name that is a R or C ref', () => {
+      expect(tokenize("'C'!R[-9]C[-3]", { r1c1: true })).toEqual([
+        { type: REF_RANGE, value: "'C'!R[-9]C[-3]" }
+      ]);
+      expect(tokenize('C!R[-9]C[-3]', { r1c1: true })).toEqual([
+        { type: REF_RANGE, value: 'C!R[-9]C[-3]' }
+      ]);
+    });
+  });
 });

package/lib/tokenize.ts

@@ -8,11 +8,13 @@ import {
   WHITESPACE,
   FUNCTION,
   OPERATOR_TRIM,
-  REF_RANGE
+  REF_RANGE,
+  REF_BEAM
 } from './constants.ts';
 import { mergeRefTokens } from './mergeRefTokens.ts';
 import { lexers, type PartLexer } from './lexers/sets.ts';
 import type { Token } from './types.ts';
+import { isRCTokenValue } from './isRCTokenValue.ts';
 
 const reLetLambda = /^l(?:ambda|et)$/i;
 const isType = (t: Token, type: string) => t && t.type === type;
@@ -27,12 +29,13 @@ const causesBinaryMinus = (token: Token) => {
   );
 };
 
-function fixRCNames (tokens: Token[]): Token[] {
+function fixRCNames (tokens: Token[], r1c1Mode?: boolean): Token[] {
   let withinCall = 0;
   let parenDepth = 0;
   let lastToken: Token;
   for (const token of tokens) {
-    if (token.type === OPERATOR) {
+    const tokenType = token.type;
+    if (tokenType === OPERATOR) {
       if (token.value === '(') {
         parenDepth++;
         if (lastToken.type === FUNCTION) {
@@ -48,7 +51,10 @@ function fixRCNames (tokens: Token[]): Token[] {
         }
       }
     }
-    else if (withinCall && token.type === UNKNOWN && /^[rc]$/.test(token.value)) {
+    else if (withinCall && tokenType === UNKNOWN && isRCTokenValue(token.value)) {
+      token.type = REF_NAMED;
+    }
+    else if (withinCall && r1c1Mode && tokenType === REF_BEAM && isRCTokenValue(token.value)) {
       token.type = REF_NAMED;
     }
     lastToken = token;
@@ -159,10 +165,12 @@ export function getTokens (fx: string, tokenHandlers: PartLexer[], options: Opts
         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;
+    // Make a note if we found a R or C unknown or REF_BEAM token in R1C1 mode.
+    // It seemse unlikely that anyone does `F2 = LET(c,1,c+F:F)` as this is a
+    // circular reference (and not a very useful one), so we're assuming that
+    // all "c" or "r" tokens found within the LET are names.
+    if (token.value.length === 1 && (token.type === UNKNOWN || (opts.r1c1 && token.type === REF_BEAM))) {
+      unknownRC += isRCTokenValue(token.value) ? 1 : 0;
     }
 
     if (negativeNumbers && token.type === NUMBER) {
@@ -195,7 +203,7 @@ export function getTokens (fx: string, tokenHandlers: PartLexer[], options: Opts
   // 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);
+    fixRCNames(tokens, opts.r1c1);
   }
 
   // Any OPERATOR_TRIM tokens have been indexed already, they now need to be

package/lib/translateToA1.spec.ts

@@ -245,3 +245,87 @@ describe('translate works with trimmed ranges', () => {
     ]);
   });
 });
+
+describe('translate r & c as LET parameters', () => {
+  // Unlike in A1, LET(c,1,c) is not valid syntax with the R1C1 notation in Excel.
+  // If you create a cell with this expression in A1 mode and flip to R1C1, Excel
+  // will not change it when expressing it, but will not allow you to re-enter it.
+  //
+  // Excel will always save the formula such as the arguments will have a "_xlpm."
+  // prefix: _xlfn.LET(_xlpm.c,1,_xlpm.c)
+  //
+  // However, that is also invalid syntax in the exposed/common Excel formula syntax.
+  // To counter this, fx does the following:
+  //
+  // tokenize:
+  //    Supports _xlpm.c in both modes.
+  //    Assumes c, C, r and R are names when encountered as tokens within LET functions.
+  // translateTokensToR1C1:
+  //    Tries to be unambiguous by serializing "c" ranges in within LET as C[0].
+  //    Same goes for "r" to R[0]. Prefixed names are left as they are.
+  //    This way round-tripping is possible.
+  function testExpr (expr: string, anchor: string, expected: any[]) {
+    const opts = { mergeRefs: true, r1c1: true };
+    expect(translateTokensToA1(tokenizeXlsx(expr, opts), anchor)).toEqual(expected);
+  }
+
+  test('translate prefixed r & c in LET', () => {
+    testExpr('_xlfn.LET(_xlpm.c,3,_xlpm.c)', 'B2', [
+      { type: 'func', value: '_xlfn.LET' },
+      { type: 'operator', value: '(' },
+      { type: 'range_named', value: '_xlpm.c' },
+      { type: 'operator', value: ',' },
+      { type: 'number', value: '3' },
+      { type: 'operator', value: ',' },
+      { type: 'range_named', value: '_xlpm.c' },
+      { type: 'operator', value: ')' }
+    ]);
+
+    testExpr('_xlfn.LET(_xlpm.r,3,_xlpm.r)', 'B2', [
+      { type: 'func', value: '_xlfn.LET' },
+      { type: 'operator', value: '(' },
+      { type: 'range_named', value: '_xlpm.r' },
+      { type: 'operator', value: ',' },
+      { type: 'number', value: '3' },
+      { type: 'operator', value: ',' },
+      { type: 'range_named', value: '_xlpm.r' },
+      { type: 'operator', value: ')' }
+    ]);
+  });
+
+  test('Converting ', () => {
+    // The syntax is invalid so it will regress:
+    isR2A('=LET(r,R,r+R)', 'B4', '=LET(r,R,r+R)');
+    isR2A('=LET(c,C,c+C)', 'B4', '=LET(c,C,c+C)');
+    // R[0] and C[0] work as expected
+    isR2A('=LET(r,R[0],r+R[0])', 'B4', '=LET(r,4:4,r+4:4)');
+    isR2A('=LET(c,C[0],c+C[0])', 'B4', '=LET(c,B:B,c+B:B)');
+    // prefixed parameters work too
+    isR2A('=LET(_xlpm.r,R[0],_xlpm.r+R[0])', 'B4', '=LET(_xlpm.r,4:4,_xlpm.r+4:4)');
+    isR2A('=LET(_xlpm.c,C[0],_xlpm.c+C[0])', 'B4', '=LET(_xlpm.c,B:B,_xlpm.c+B:B)');
+  });
+
+  test('translate r & c in LET', () => {
+    testExpr('LET(c,3,c)', 'B2', [
+      { type: 'func', value: 'LET' },
+      { type: 'operator', value: '(' },
+      { type: 'range_named', value: 'c' },
+      { type: 'operator', value: ',' },
+      { type: 'number', value: '3' },
+      { type: 'operator', value: ',' },
+      { type: 'range_named', value: 'c' },
+      { type: 'operator', value: ')' }
+    ]);
+
+    testExpr('LET(r,3,r)', 'B2', [
+      { type: 'func', value: 'LET' },
+      { type: 'operator', value: '(' },
+      { type: 'range_named', value: 'r' },
+      { type: 'operator', value: ',' },
+      { type: 'number', value: '3' },
+      { type: 'operator', value: ',' },
+      { type: 'range_named', value: 'r' },
+      { type: 'operator', value: ')' }
+    ]);
+  });
+});

package/lib/translateToA1.ts

@@ -103,49 +103,51 @@ export function translateTokensToA1 (
       // We can get away with using the xlsx ref-parser here because it is more permissive
       // and we will end up with the same prefix after serialization anyway:
       const ref = parseR1C1RefXlsx(tokenValue, REF_OPTS) as ReferenceR1C1Xlsx;
-      const d = ref.range;
-      const range: RangeA1 = { top: 0, left: 0 };
-      const r0 = toFixed(d.r0, d.$r0, top, MAX_ROWS, wrapEdges);
-      const r1 = toFixed(d.r1, d.$r1, top, MAX_ROWS, wrapEdges);
-      if (r0 > r1) {
-        range.top = r1;
-        range.$top = d.$r1;
-        range.bottom = r0;
-        range.$bottom = d.$r0;
-      }
-      else {
-        range.top = r0;
-        range.$top = d.$r0;
-        range.bottom = r1;
-        range.$bottom = d.$r1;
-      }
-      const c0 = toFixed(d.c0, d.$c0, left, MAX_COLS, wrapEdges);
-      const c1 = toFixed(d.c1, d.$c1, left, MAX_COLS, wrapEdges);
-      if (c0 > c1) {
-        range.left = c1;
-        range.$left = d.$c1;
-        range.right = c0;
-        range.$right = d.$c0;
-      }
-      else {
-        range.left = c0;
-        range.$left = d.$c0;
-        range.right = c1;
-        range.$right = d.$c1;
-      }
-      if (d.trim) {
-        range.trim = d.trim;
-      }
-      if (isNaN(r0) || isNaN(r1) || isNaN(c0) || isNaN(c1)) {
-        // convert to ref error
-        token.type = ERROR;
-        token.value = '#REF!';
-        delete token.groupId;
-      }
-      else {
-        ref.range = range;
-        // @ts-expect-error -- reusing the object, switching it to A1 by swapping the range
-        token.value = stringifyA1RefXlsx(ref);
+      if (ref) {
+        const d = ref.range;
+        const range: RangeA1 = { top: 0, left: 0 };
+        const r0 = toFixed(d.r0, d.$r0, top, MAX_ROWS, wrapEdges);
+        const r1 = toFixed(d.r1, d.$r1, top, MAX_ROWS, wrapEdges);
+        if (r0 > r1) {
+          range.top = r1;
+          range.$top = d.$r1;
+          range.bottom = r0;
+          range.$bottom = d.$r0;
+        }
+        else {
+          range.top = r0;
+          range.$top = d.$r0;
+          range.bottom = r1;
+          range.$bottom = d.$r1;
+        }
+        const c0 = toFixed(d.c0, d.$c0, left, MAX_COLS, wrapEdges);
+        const c1 = toFixed(d.c1, d.$c1, left, MAX_COLS, wrapEdges);
+        if (c0 > c1) {
+          range.left = c1;
+          range.$left = d.$c1;
+          range.right = c0;
+          range.$right = d.$c0;
+        }
+        else {
+          range.left = c0;
+          range.$left = d.$c0;
+          range.right = c1;
+          range.$right = d.$c1;
+        }
+        if (d.trim) {
+          range.trim = d.trim;
+        }
+        if (isNaN(r0) || isNaN(r1) || isNaN(c0) || isNaN(c1)) {
+          // convert to ref error
+          token.type = ERROR;
+          token.value = '#REF!';
+          delete token.groupId;
+        }
+        else {
+          ref.range = range;
+          // @ts-expect-error -- reusing the object, switching it to A1 by swapping the range
+          token.value = stringifyA1RefXlsx(ref);
+        }
       }
       // if token includes offsets, those offsets are now likely wrong!
       if (token.loc) {