@borgar/fx 4.8.0 → 4.10.0

package/lib/lexer.js

@@ -7,7 +7,9 @@ import {
   STRING,
   UNKNOWN,
   WHITESPACE,
-  FUNCTION
+  FUNCTION,
+  OPERATOR_TRIM,
+  REF_RANGE
 } from './constants.js';
 import { lexers } from './lexerParts.js';
 import { mergeRefTokens } from './mergeRefTokens.js';
@@ -75,6 +77,7 @@ export function getTokens (fx, tokenHandlers, options = {}) {
   let pos = 0;
   let letOrLambda = 0;
   let unknownRC = 0;
+  const trimOps = [];
 
   let tail0 = null; // last non-whitespace token
   let tail1 = null; // penultimate non-whitespace token
@@ -95,6 +98,10 @@ export function getTokens (fx, tokenHandlers, options = {}) {
       }
     }
     else {
+      if (token.type === OPERATOR_TRIM) {
+        trimOps.push(tokens.length);
+        token.type = UNKNOWN;
+      }
       // push token as normally
       tokens.push(token);
       lastToken = token;
@@ -105,7 +112,7 @@ export function getTokens (fx, tokenHandlers, options = {}) {
     }
   };
 
-  if (/^=/.test(fx)) {
+  if (fx.at(0) === '=') {
     const token = {
       type: FX_PREFIX,
       value: '=',
@@ -208,6 +215,21 @@ export function getTokens (fx, tokenHandlers, options = {}) {
     fixRCNames(tokens);
   }
 
+  // Any OPERATOR_TRIM tokens have been indexed already, they now need to be
+  // either turned into OPERATORs or UNKNOWNs. Trim operators are only allowed
+  // between two REF_RANGE tokens as they are not valid in expressions as full
+  // operators.
+  for (const index of trimOps) {
+    const before = tokens[index - 1];
+    const after = tokens[index - 1];
+    if (before && before.type === REF_RANGE && after && after.type === REF_RANGE) {
+      tokens[index].type = OPERATOR;
+    }
+    else {
+      tokens[index].type = UNKNOWN;
+    }
+  }
+
   if (mergeRefs) {
     return mergeRefTokens(tokens);
   }

package/lib/lexer.spec.js

@@ -969,6 +969,21 @@ test('tokenize A1 style references', t => {
     { type: REF_RANGE, value: 'A10:A20' }
   ]);
 
+  t.isTokens('=A10.:A20', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: 'A10.:A20' }
+  ]);
+
+  t.isTokens('=A10:.A20', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: 'A10:.A20' }
+  ]);
+
+  t.isTokens('=A10.:.A20', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_RANGE, value: 'A10.:.A20' }
+  ]);
+
   t.isTokens('=A10:E20', [
     { type: FX_PREFIX, value: '=' },
     { type: REF_RANGE, value: 'A10:E20' }
@@ -984,6 +999,21 @@ test('tokenize A1 style references', t => {
     { type: REF_BEAM, value: '5:5' }
   ]);
 
+  t.isTokens('=5.:5', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_BEAM, value: '5.:5' }
+  ]);
+
+  t.isTokens('=5:.5', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_BEAM, value: '5:.5' }
+  ]);
+
+  t.isTokens('=5.:.5', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_BEAM, value: '5.:.5' }
+  ]);
+
   t.isTokens('=15:15', [
     { type: FX_PREFIX, value: '=' },
     { type: REF_BEAM, value: '15:15' }
@@ -994,6 +1024,21 @@ test('tokenize A1 style references', t => {
     { type: REF_BEAM, value: 'H:H' }
   ]);
 
+  t.isTokens('=H.:H', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_BEAM, value: 'H.:H' }
+  ]);
+
+  t.isTokens('=H:.H', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_BEAM, value: 'H:.H' }
+  ]);
+
+  t.isTokens('=H.:.H', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_BEAM, value: 'H.:.H' }
+  ]);
+
   t.isTokens('=AA:JJ', [
     { type: FX_PREFIX, value: '=' },
     { type: REF_BEAM, value: 'AA:JJ' }
@@ -1222,6 +1267,15 @@ test('tokenize A1 style references', t => {
     { type: REF_BEAM, value: 'B:B' }
   ], { mergeRefs: false });
 
+  t.isTokens('=Sheet1!A.:.A:B.:.B', [
+    { type: FX_PREFIX, value: '=' },
+    { type: CONTEXT, value: 'Sheet1' },
+    { type: OPERATOR, value: '!' },
+    { type: REF_BEAM, value: 'A.:.A' },
+    { type: OPERATOR, value: ':' },
+    { type: REF_BEAM, value: 'B.:.B' }
+  ], { mergeRefs: false });
+
   t.isTokens('=Sheet1!#REF!:A1', [
     { type: FX_PREFIX, value: '=' },
     { type: CONTEXT, value: 'Sheet1' },
@@ -1832,3 +1886,55 @@ test('tokenize r and c as names within LET and LAMBDA calls', t => {
 
   t.end();
 });
+
+test('trim operators are not valid outside literal ranges', t => {
+  // when not merging refs, trim ops are allowed between ranges
+  t.isTokens('=Sheet1!A1.:.B2', [
+    { type: FX_PREFIX, value: '=' },
+    { type: CONTEXT, value: 'Sheet1' },
+    { type: OPERATOR, value: '!' },
+    { type: REF_RANGE, value: 'A1' },
+    { type: OPERATOR, value: '.:.' },
+    { type: REF_RANGE, value: 'B2' }
+  ], { mergeRefs: false });
+  t.isTokens('A1:.B2', [
+    { type: REF_RANGE, value: 'A1' },
+    { type: OPERATOR, value: ':.' },
+    { type: REF_RANGE, value: 'B2' }
+  ], { mergeRefs: false });
+  t.isTokens('A1.:B2', [
+    { type: REF_RANGE, value: 'A1' },
+    { type: OPERATOR, value: '.:' },
+    { type: REF_RANGE, value: 'B2' }
+  ], { mergeRefs: false });
+
+  t.isTokens('=Sheet1!A.:.A.:.B.:.B', [
+    { type: FX_PREFIX, value: '=' },
+    { type: REF_BEAM, value: 'Sheet1!A.:.A' },
+    { type: UNKNOWN, value: '.:.' },
+    { type: REF_BEAM, value: 'B.:.B' }
+  ]);
+
+  t.isTokens('=name1.:.name2', [
+    { type: 'fx_prefix', value: '=' },
+    { type: REF_NAMED, value: 'name1.' },
+    { type: 'unknown', value: ':.name2' }
+  ]);
+
+  t.isTokens('=OFFSET(A1,1,1).:.INDIRECT("A1")', [
+    { type: 'fx_prefix', value: '=' },
+    { type: 'func', value: 'OFFSET' },
+    { type: 'operator', value: '(' },
+    { type: 'range', value: 'A1' },
+    { type: 'operator', value: ',' },
+    { type: 'number', value: '1' },
+    { type: 'operator', value: ',' },
+    { type: 'number', value: '1' },
+    { type: 'operator', value: ')' },
+    { type: 'unknown', value: '.:.INDIRECT' },
+    { type: 'operator', value: '(' },
+    { type: 'string', value: '"A1"' },
+    { type: 'operator', value: ')' }
+  ]);
+  t.end();
+});

package/lib/lexerParts.js

@@ -15,7 +15,8 @@ import {
   REF_TERNARY,
   REF_STRUCT,
   MAX_COLS,
-  MAX_ROWS
+  MAX_ROWS,
+  OPERATOR_TRIM
 } from './constants.js';
 import { fromCol } from './a1.js';
 import { parseSRange } from './sr.js';
@@ -30,21 +31,23 @@ const re_STRING = /^"(?:""|[^"])*("|$)/;
 const re_NUMBER = /^(?:\d+(\.\d+)?(?:[eE][+-]?\d+)?|\d+)/;
 const re_CONTEXT = /^(?!!)(\[(?:[^\]])+\])?([0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff]+)?(?=!)/;
 const re_CONTEXT_QUOTE = /^'(?:''|[^'])*('|$)(?=!)/;
+const re_RANGE_TRIM = /^(\.:\.|\.:|:\.)/;
 
 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 rangeOp = '\\.?:\\.?';
 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_A1COL = new RegExp(`^${colPart}${rangeOp}${colPart}${nextNotChar}`, 'i');
+const re_A1ROW = new RegExp(`^${rowPart}${rangeOp}${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 re_A1PARTIAL = new RegExp(`^((${colPart}|${rowPart})${rangeOp}${rngPart}|${rngPart}${rangeOp}(${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})?${nextNotChar}`, 'i');
-const re_RCROW = new RegExp(`^${rPart}(:${rPart})?${nextNotChar}`, 'i');
+const re_RCCOL = new RegExp(`^${cPart}(${rangeOp}${cPart})?${nextNotChar}`, 'i');
+const re_RCROW = new RegExp(`^${rPart}(${rangeOp}${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');
+const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(${rangeOp}${cPart}|${rangeOp}${rPart})(?![[\\d])|(${rPart}|${cPart})(${rangeOp}${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
@@ -169,6 +172,7 @@ function lexRange (str, options) {
     }
     if (t) {
       reA1Nums.lastIndex = 0;
+      // XXX: can probably optimize this as we know letters can only be 3 at max
       while ((m = reA1Nums.exec(t.value)) !== null) {
         if (/^\d/.test(m[1])) { // row
           if ((parseInt(m[1], 10) - 1) > MAX_ROWS) {
@@ -191,14 +195,17 @@ function lexRefOp (s, opts) {
       ? { type: OPERATOR, value: s[0] }
       : null;
   }
-  // in A1 mode we allow ! and :
-  return (s[0] === '!' || s[0] === ':')
-    ? { type: OPERATOR, value: s[0] }
-    : null;
+  // in A1 mode we allow [ '!', ':', '.:', ':.', '.:.']
+  const m = /^(!|\.?:\.?)/.exec(s);
+  if (m) {
+    return { type: OPERATOR, value: m[1] };
+  }
+  return null;
 }
 
 export const lexers = [
   makeHandler(ERROR, re_ERROR),
+  makeHandler(OPERATOR_TRIM, re_RANGE_TRIM),
   makeHandler(OPERATOR, re_OPERATOR),
   makeHandler(FUNCTION, re_FUNCTION),
   makeHandler(BOOLEAN, re_BOOLEAN),

package/lib/mergeRefTokens.js

@@ -4,14 +4,23 @@ const END = '$';
 
 const validRunsMerge = [
   [ REF_RANGE, ':', REF_RANGE ],
+  [ REF_RANGE, '.:', REF_RANGE ],
+  [ REF_RANGE, ':.', REF_RANGE ],
+  [ REF_RANGE, '.:.', REF_RANGE ],
   [ 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_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_RANGE ],
   [ CONTEXT_QUOTE, '!', REF_BEAM ],
   [ CONTEXT_QUOTE, '!', REF_TERNARY ],

package/lib/mergeRefTokens.spec.js

@@ -95,6 +95,9 @@ test('mergeRefTokens cases', t => {
   t.deepEqual(tokenize('[WB]Sheet1!A1:A', opts), [
     { type: REF_TERNARY, value: '[WB]Sheet1!A1:A' }
   ]);
+  t.deepEqual(tokenize('[WB]Sheet1!A1.:.C3', opts), [
+    { type: REF_RANGE, value: '[WB]Sheet1!A1.:.C3' }
+  ]);
 
   t.deepEqual(tokenize('foo', opts), [
     { type: REF_NAMED, value: 'foo' }

package/lib/parseRef.js

@@ -71,7 +71,7 @@ function splitContextXlsx (contextString) {
 
 const unquote = d => d.slice(1, -1).replace(/''/g, "'");
 
-const pRangeOp = t => t && t.value === ':' && {};
+const pRangeOp = t => t && (t.value === ':' || t.value === '.:' || t.value === ':.' || t.value === '.:.') && { operator: t.value };
 const pRange = t => t && t.type === REF_RANGE && { r0: t.value };
 const pPartial = t => t && t.type === REF_TERNARY && { r0: t.value };
 const pRange2 = t => t && t.type === REF_RANGE && { r1: t.value };
@@ -125,13 +125,15 @@ export function parseRef (ref, opts) {
       sheetName: '',
       r0: '',
       r1: '',
-      name: ''
+      name: '',
+      operator: ''
     }
     : {
       context: [],
       r0: '',
       r1: '',
-      name: ''
+      name: '',
+      operator: ''
     };
   // discard the "="-prefix if it is there
   if (tokens.length && tokens[0].type === FX_PREFIX) {

package/lib/parser.js

@@ -59,6 +59,7 @@ const refFunctions = [
   'SINGLE',
   'SWITCH',
   'TAKE',
+  'TRIMRANGE',
   'XLOOKUP'
 ];
 

package/lib/parser.spec.js

@@ -70,6 +70,7 @@ test('parse ranges', t => {
   t.isParsed('1:2', { type: 'ReferenceIdentifier', value: '1:2', kind: 'beam' });
   t.isParsed('A1:2', { type: 'ReferenceIdentifier', value: 'A1:2', kind: 'range' });
   t.isParsed('1:A2', { type: 'ReferenceIdentifier', value: '1:A2', kind: 'range' });
+  t.isParsed('A1.:.B2', { type: 'ReferenceIdentifier', value: 'A1.:.B2', kind: 'range' });
   t.isParsed('Sheet!A1', { type: 'ReferenceIdentifier', value: 'Sheet!A1', kind: 'range' });
   t.isParsed('[Workbook]Sheet!A1', { type: 'ReferenceIdentifier', value: '[Workbook]Sheet!A1', kind: 'range' });
   t.isParsed('\'Sheet\'!A1', { type: 'ReferenceIdentifier', value: '\'Sheet\'!A1', kind: 'range' });

package/lib/rc.js

@@ -6,6 +6,7 @@
 ** - R[1]C1:R[2]C2 will also work, but
 ** - R[1]C[1]:R2C2 doesn't have a direct rectangle represention without context.
 */
+import { rangeOperator, trimDirection } from './a1.js';
 import { MAX_ROWS, MAX_COLS } from './constants.js';
 import { parseRef } from './parseRef.js';
 import { stringifyPrefix, stringifyPrefixAlt } from './stringifyPrefix.js';
@@ -35,6 +36,8 @@ export function toR1C1 (range) {
   const nullC0 = c0 == null;
   let nullR1 = r1 == null;
   let nullC1 = c1 == null;
+  const op = rangeOperator(range.trim);
+  const hasTrim = !!range.trim;
   r0 = clamp($r0 ? 0 : -MAX_ROWS, r0 | 0, MAX_ROWS);
   c0 = clamp($c0 ? 0 : -MAX_COLS, c0 | 0, MAX_COLS);
   if (!nullR0 && nullR1 && !nullC0 && nullC1) {
@@ -52,14 +55,14 @@ export function toR1C1 (range) {
   if ((allRows && !nullC0 && !nullC1) || (nullR0 && nullR1)) {
     const a = toCoord(c0, $c0);
     const b = toCoord(c1, $c1);
-    return 'C' + (a === b ? a : a + ':C' + b);
+    return 'C' + (a === b && !hasTrim ? a : a + op + 'C' + b);
   }
   // R:R
   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);
+    return 'R' + (a === b && !hasTrim ? a : a + op + 'R' + b);
   }
   const s_r0 = toCoord(r0, $r0);
   const s_r1 = toCoord(r1, $r1);
@@ -70,14 +73,14 @@ export function toR1C1 (range) {
     return (
       (nullR0 ? '' : 'R' + s_r0) +
       (nullC0 ? '' : 'C' + s_c0) +
-      ':' +
+      op +
       (nullR1 ? '' : 'R' + s_r1) +
       (nullC1 ? '' : 'C' + s_c1)
     );
   }
   // RC:RC
   if (s_r0 !== s_r1 || s_c0 !== s_c1) {
-    return 'R' + s_r0 + 'C' + s_c0 + ':R' + s_r1 + 'C' + s_c1;
+    return 'R' + s_r0 + 'C' + s_c0 + op + 'R' + s_r1 + 'C' + s_c1;
   }
   // RC
   return 'R' + s_r0 + 'C' + s_c0;
@@ -140,8 +143,12 @@ function parseR1C1Part (ref) {
  */
 export function fromR1C1 (rangeString) {
   let final = null;
-  const [ part1, part2 ] = rangeString.split(':', 2);
+  const [ part1, op, part2, overflow ] = rangeString.split(/(\.?:\.?)/);
+  if (overflow) {
+    return null;
+  }
   const range = parseR1C1Part(part1);
+  const trim = trimDirection(!!op && op.at(0) === '.', !!op && op.at(-1) === '.');
   if (range) {
     const [ r0, c0, $r0, $c0 ] = range;
     if (part2) {
@@ -209,7 +216,7 @@ export function fromR1C1 (rangeString) {
     }
     // range only - no second part
     else if (r0 != null && c0 == null) {
-      return {
+      final = {
         r0: r0,
         c0: null,
         r1: r0,
@@ -221,7 +228,7 @@ export function fromR1C1 (rangeString) {
       };
     }
     else if (r0 == null && c0 != null) {
-      return {
+      final = {
         r0: null,
         c0: c0,
         r1: null,
@@ -233,7 +240,7 @@ export function fromR1C1 (rangeString) {
       };
     }
     else {
-      return {
+      final = {
         r0: r0 || 0,
         c0: c0 || 0,
         r1: r0 || 0,
@@ -245,6 +252,9 @@ export function fromR1C1 (rangeString) {
       };
     }
   }
+  if (final && trim) {
+    final.trim = trim;
+  }
   return final;
 }
 
@@ -279,17 +289,19 @@ export function parseR1C1Ref (refString, { allowNamed = true, allowTernary = fal
   const d = parseRef(refString, { allowNamed, allowTernary, xlsx, r1c1: true });
   if (d && (d.r0 || d.name)) {
     const range = d.r1
-      ? fromR1C1(d.r0 + ':' + d.r1)
+      ? fromR1C1(d.r0 + d.operator + d.r1)
       : fromR1C1(d.r0);
-    if (d.name || range) {
-      d.range = range;
-      delete d.r0;
-      delete d.r1;
-      return d;
+    if (range) {
+      return xlsx
+        ? { workbookName: d.workbookName, sheetName: d.sheetName, range }
+        : { context: d.context, range };
     }
-    else {
-      return null;
+    if (d.name) {
+      return xlsx
+        ? { workbookName: d.workbookName, sheetName: d.sheetName, name: d.name }
+        : { context: d.context, name: d.name };
     }
+    return null;
   }
   return null;
 }

package/lib/rc.spec.js

@@ -6,19 +6,8 @@ import { parseR1C1Ref, stringifyR1C1Ref, toR1C1 } from './rc.js';
 Test.prototype.isRCEqual = function isTokens (expr, expect, opts) {
   if (expect) {
     expect = (opts?.xlsx)
-      ? {
-        workbookName: '',
-        sheetName: '',
-        name: '',
-        range: null,
-        ...expect
-      }
-      : {
-        context: [],
-        name: '',
-        range: null,
-        ...expect
-      };
+      ? { workbookName: '', sheetName: '', ...expect }
+      : { context: [], ...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 = {
@@ -261,6 +250,43 @@ test('parse R1C1 ranges in XLSX mode', t => {
   t.end();
 });
 
+test('R1C1 trimmed ranges', t => {
+  const locks = { $r0: true, $r1: true, $c0: true, $c1: true };
+  const opts = [ {}, { xlsx: true } ];
+  for (const opt of opts) {
+    t.isRCEqual('R[1]C[1]:R[2]C[2]', { range: { r0: 1, r1: 2, c0: 1, c1: 2 } }, opt);
+    t.isRCEqual('R[1]C[1].:R[2]C[2]', { range: { r0: 1, r1: 2, c0: 1, c1: 2, trim: 'head' } }, opt);
+    t.isRCEqual('R[1]C[1]:.R[2]C[2]', { range: { r0: 1, r1: 2, c0: 1, c1: 2, trim: 'tail' } }, opt);
+    t.isRCEqual('R[1]C[1].:.R[2]C[2]', { range: { r0: 1, r1: 2, c0: 1, c1: 2, trim: 'both' } }, opt);
+
+    t.isRCEqual('R2C2:R3C3', { range: { r0: 1, r1: 2, c0: 1, c1: 2, ...locks } }, opt);
+    t.isRCEqual('R2C2.:R3C3', { range: { r0: 1, r1: 2, c0: 1, c1: 2, trim: 'head', ...locks } }, opt);
+    t.isRCEqual('R2C2:.R3C3', { range: { r0: 1, r1: 2, c0: 1, c1: 2, trim: 'tail', ...locks } }, opt);
+    t.isRCEqual('R2C2.:.R3C3', { range: { r0: 1, r1: 2, c0: 1, c1: 2, trim: 'both', ...locks } }, opt);
+
+    t.isRCEqual('C[1]:C[2]', { range: { c0: 1, c1: 2 } }, opt);
+    t.isRCEqual('C[1].:C[2]', { range: { c0: 1, c1: 2, trim: 'head' } }, opt);
+    t.isRCEqual('C[1]:.C[2]', { range: { c0: 1, c1: 2, trim: 'tail' } }, opt);
+    t.isRCEqual('C[1].:.C[2]', { range: { c0: 1, c1: 2, trim: 'both' } }, opt);
+
+    t.isRCEqual('R[10]:R[10]', { range: { r0: 10, r1: 10 } }, opt);
+    t.isRCEqual('R[10].:R[10]', { range: { r0: 10, r1: 10, trim: 'head' } }, opt);
+    t.isRCEqual('R[10]:.R[10]', { range: { r0: 10, r1: 10, trim: 'tail' } }, opt);
+    t.isRCEqual('R[10].:.R[10]', { range: { r0: 10, r1: 10, trim: 'both' } }, opt);
+
+    t.isRCEqual('R[2]C[2]:R[4]', null, { ...opt });
+    t.isRCEqual('R[2]C[2]:C[4]', null, { ...opt });
+    t.isRCEqual('R[2]C[2].:.R[4]', null, { ...opt });
+    t.isRCEqual('R[2]C[2].:.C[4]', null, { ...opt });
+
+    t.isRCEqual('R[2]C[2]:R[4]', { range: { r0: 2, r1: 4, c0: 2 } }, { allowTernary: true, ...opt });
+    t.isRCEqual('R[2]C[2]:C[4]', { range: { r0: 2, c0: 2, c1: 4 } }, { allowTernary: true, ...opt });
+    t.isRCEqual('R[2]C[2].:.R[4]', { range: { r0: 2, r1: 4, c0: 2, trim: 'both' } }, { allowTernary: true, ...opt });
+    t.isRCEqual('R[2]C[2].:.C[4]', { range: { r0: 2, c0: 2, c1: 4, trim: 'both' } }, { allowTernary: true, ...opt });
+  }
+  t.end();
+});
+
 test('R1C1 serialization', t => {
   // ray
   t.isR1C1Rendered({ r0: 0, c0: 0, r1: 0, c1: MAX_COLS }, 'R');
@@ -317,6 +343,19 @@ test('R1C1 serialization', t => {
   t.isR1C1Rendered({ r0: -15e5, c0: 0, r1: 15e5, c1: 0 }, 'R[-1048575]C:R[1048575]C');
   t.isR1C1Rendered({ r0: 0.5, c0: 0.5, r1: 0.5, c1: 0.5, ...abs }, 'R1C1');
   t.isR1C1Rendered({ r0: 0.5, c0: 0.5, r1: 0.5, c1: 0.5 }, 'RC');
+  // trimming
+  t.isR1C1Rendered({ r0: 1, c0: 1, r1: 2, c1: 2 }, 'R[1]C[1]:R[2]C[2]');
+  t.isR1C1Rendered({ r0: 1, c0: 1, r1: 2, c1: 2, trim: 'head' }, 'R[1]C[1].:R[2]C[2]');
+  t.isR1C1Rendered({ r0: 1, c0: 1, r1: 2, c1: 2, trim: 'tail' }, 'R[1]C[1]:.R[2]C[2]');
+  t.isR1C1Rendered({ r0: 1, c0: 1, r1: 2, c1: 2, trim: 'both' }, 'R[1]C[1].:.R[2]C[2]');
+  t.isR1C1Rendered({ r0: 1, c0: 1, r1: 1, c1: 1, trim: 'both' }, 'R[1]C[1]');
+  t.isR1C1Rendered({ r0: 1, r1: 1 }, 'R[1]');
+  t.isR1C1Rendered({ r0: 1, r1: 1, trim: 'head' }, 'R[1].:R[1]');
+  t.isR1C1Rendered({ r0: 1, r1: 1, trim: 'both' }, 'R[1].:.R[1]');
+  t.isR1C1Rendered({ c0: 1, c1: 1 }, 'C[1]');
+  t.isR1C1Rendered({ c0: 1, c1: 1, trim: 'tail' }, 'C[1]:.C[1]');
+  t.isR1C1Rendered({ c0: 1, c1: 1, trim: 'both' }, 'C[1].:.C[1]');
+  t.isR1C1Rendered({ r0: -5, c0: -2, c1: -2, trim: 'both' }, 'R[-5]C[-2].:.C[-2]');
   t.end();
 });
 

package/lib/sr.js

@@ -241,9 +241,11 @@ function toSentenceCase (str) {
  * @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)
+ * @param {boolean} [options.thisRow=false]  Enforces using the `[#This Row]` instead of the `@` shorthand when serializing structured ranges.
  * @returns {string} The structured reference in string format
  */
-export function stringifyStructRef (refObject, { xlsx = false } = {}) {
+export function stringifyStructRef (refObject, options = {}) {
+  const { xlsx, thisRow } = options;
   let s = xlsx
     ? stringifyPrefixAlt(refObject)
     : stringifyPrefix(refObject);
@@ -263,8 +265,8 @@ export function stringifyStructRef (refObject, { xlsx = false } = {}) {
   }
   else {
     s += '[';
-    // single [#this row] sections get normalized to an @
-    const singleAt = numSections === 1 && refObject.sections[0].toLowerCase() === 'this row';
+    // single [#this row] sections get normalized to an @ by default
+    const singleAt = !thisRow && numSections === 1 && refObject.sections[0].toLowerCase() === 'this row';
     if (singleAt) {
       s += '@';
     }

package/lib/sr.spec.js

@@ -278,3 +278,53 @@ test('structured references parse and serialize in xlsx mode', t => {
   t.end();
 });
 
+test.only('longform serialize (in xlsx mode)', t => {
+  // thisRow should have no effect when parsing
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: true, thisRow: true });
+
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: true, thisRow: false });
+
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: false, thisRow: true });
+
+  t.isSREqual('Table2[[#This Row],[col1]]', {
+    table: 'Table2',
+    columns: [ 'col1' ],
+    sections: [ 'this row' ]
+  }, { xlsx: false, thisRow: false });
+
+  // thisRow should mean we don't see @'s in output
+  t.is(
+    stringifyStructRef({
+      table: 'Table2',
+      columns: [ 'col1' ],
+      sections: [ 'this row' ]
+    }, { xlsx: true, thisRow: true }),
+    'Table2[[#This row],[col1]]',
+    'Table2[[#This row],[col1]] (xlsx mode)'
+  );
+
+  t.is(
+    stringifyStructRef({
+      table: 'Table2',
+      columns: [ 'col1' ],
+      sections: [ 'this row' ]
+    }, { xlsx: false, thisRow: true }),
+    'Table2[[#This row],[col1]]',
+    'Table2[[#This row],[col1]] (non xlsx mode)'
+  );
+
+  t.end();
+});
+

package/lib/stringifyPrefix.js

@@ -10,7 +10,7 @@ export function stringifyPrefix (ref) {
     if (scope) {
       const part = (nth % 2) ? '[' + scope + ']' : scope;
       pre = part + pre;
-      quote += reBannedChars.test(scope);
+      quote += +reBannedChars.test(scope);
       nth++;
     }
   }
@@ -26,11 +26,11 @@ export function stringifyPrefixAlt (ref) {
   const { workbookName, sheetName } = ref;
   if (workbookName) {
     pre += '[' + workbookName + ']';
-    quote += reBannedChars.test(workbookName);
+    quote += +reBannedChars.test(workbookName);
   }
   if (sheetName) {
     pre += sheetName;
-    quote += reBannedChars.test(sheetName);
+    quote += +reBannedChars.test(sheetName);
   }
   if (quote) {
     pre = "'" + pre.replace(/'/g, "''") + "'";