@borgar/fx 4.4.0 → 4.6.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
@@ -15,7 +16,7 @@ const toRowStr = (r, a) => (a ? '$' : '') + toRow(r);
  * return garbage.
  *
  * @param {string} columnString  The column string identifier
- * @return {number}  Zero based column index number
+ * @returns {number}  Zero based column index number
  */
 export function fromCol (columnString) {
   const x = (columnString || '');
@@ -47,13 +48,17 @@ export function fromCol (columnString) {
  * return garbage.
  *
  * @param {number} columnIndex Zero based column index number
- * @return {string} The column string identifier
+ * @returns {string} The column string identifier
  */
 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)
   );
 }
 
@@ -80,8 +85,8 @@ export function toAbsolute (range) {
  *
  * @private
  * @see parseA1Ref
- * @param {Object} range  A range object
- * @return {string}  An A1-style string represenation of a range
+ * @param {RangeA1} range  A range object
+ * @returns {string}  An A1-style string represenation of a range
  */
 export function toA1 (range) {
   let { top, left, bottom, right } = range;
@@ -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
@@ -154,9 +163,9 @@ function splitA1 (str) {
  * @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 {(RangeA1|null)} An object representing a valid range or null if it is invalid.
  */
-export function fromA1 (rangeStr) {
+export function fromA1 (rangeString) {
   let top = null;
   let left = null;
   let bottom = null;
@@ -165,7 +174,7 @@ export function fromA1 (rangeStr) {
   let $left = false;
   let $bottom = false;
   let $right = false;
-  const [ part1, part2, part3 ] = rangeStr.split(':');
+  const [ part1, part2, part3 ] = rangeString.split(':');
   if (part3) {
     return null;
   }
@@ -241,11 +250,11 @@ export function fromA1 (rangeStr) {
  * syntax does not specify:
  *
  * @param {string} refString  An A1-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 {(ReferenceA1|null)} An object representing a valid reference or null if it is invalid.
  */
 export function parseA1Ref (refString, { allowNamed = true, allowTernary = false, xlsx = false } = {}) {
   const d = parseRef(refString, { allowNamed, allowTernary, xlsx, r1c1: false });
@@ -287,10 +296,10 @@ export function parseA1Ref (refString, { allowNamed = true, allowTernary = false
  * // => 'Sheet1!A$1:$B2'
  * ```
  *
- * @param {Object} refObject A reference object
- * @param {Object} [options={}]  Options
+ * @param {ReferenceA1} 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 A1-style string format
+ * @returns {string} The reference in A1-style string format
  */
 export function stringifyA1Ref (refObject, { xlsx = false } = {}) {
   const prefix = xlsx
@@ -332,8 +341,8 @@ export function stringifyA1Ref (refObject, { xlsx = false } = {}) {
  * // }
  * ```
  *
- * @param {Object} range The range part of a reference object.
- * @return {Object} same range with missing bounds filled in.
+ * @param {RangeA1} range The range part of a reference object.
+ * @returns {RangeA1} same range with missing bounds filled in.
  */
 export function addA1RangeBounds (range) {
   if (range.top == null) {

package/lib/addTokenMeta.js

@@ -121,13 +121,13 @@ function addContext (ref, sheetName, workbookName) {
  *
  * All will be tagged with `.error` (boolean `true`).
  *
- * @param {Array<Object>} tokenlist An array of tokens (from `tokenize()`)
- * @param {Object} [context={}] A contest used to match `A1` to `Sheet1!A1`.
+ * @param {Array<Token>} tokenlist An array of tokens (from `tokenize()`)
+ * @param {object} [context={}] A contest used to match `A1` to `Sheet1!A1`.
  * @param {string} [context.sheetName=''] An implied sheet name ('Sheet1')
  * @param {string} [context.workbookName=''] An implied workbook name ('report.xlsx')
- * @return {Array<Object>} The input array with the enchanced tokens
+ * @returns {Array<TokenEnhanced>} The input array with the enchanced tokens
  */
-export function addTokenMeta (tokens, { sheetName = '', workbookName = '' } = {}) {
+export function addTokenMeta (tokenlist, { sheetName = '', workbookName = '' } = {}) {
   const parenStack = [];
   let arrayStart = null;
   const uid = getIDer();
@@ -135,7 +135,7 @@ export function addTokenMeta (tokens, { sheetName = '', workbookName = '' } = {}
 
   const getCurrDepth = () => parenStack.length + (arrayStart ? 1 : 0);
 
-  tokens.forEach((token, i) => {
+  tokenlist.forEach((token, i) => {
     token.index = i;
     token.depth = getCurrDepth();
     if (token.value === '(') {
@@ -202,5 +202,5 @@ export function addTokenMeta (tokens, { sheetName = '', workbookName = '' } = {}
       token.error = true;
     }
   });
-  return tokens;
+  return tokenlist;
 }

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/extraTypes.js

@@ -0,0 +1,73 @@
+/**
+ * @typedef {object} Token A formula language token.
+ * @augments Record<string,any>
+ * @property {string} type The type of the token
+ * @property {string} value The value of the token
+ * @property {boolean} [unterminated] Signifies an unterminated string token
+ * @property {Array<number>} [loc] Source position offsets to the token
+ */
+
+/**
+ * @typedef {object} TokenEnhanced A token with extra meta data.
+ * @augments Token
+ * @property {number} index A zero based position in a token list
+ * @property {string} [groupId] The ID of a group which this token belongs (e.g. matching parens)
+ * @property {number} [depth] This token's level of nesting inside parentheses
+ * @property {boolean} [error] Token is of unknown type or a paren without a match
+ */
+
+/**
+ * @typedef {Record<string, any>} RangeR1C1 A range in R1C1 style coordinates.
+ * @property {number | null} [r0] Top row of the range
+ * @property {number | null} [r1] Bottom row of the range
+ * @property {number | null} [c0] Left column of the range
+ * @property {number | null} [c1] Right column of the range
+ * @property {boolean | null} [$r0] Signifies that r0 is an absolute value
+ * @property {boolean | null} [$r1] Signifies that r1 is an absolute value
+ * @property {boolean | null} [$c0] Signifies that c0 is an absolute value
+ * @property {boolean | null} [$c1] Signifies that c1 is an absolute value
+ */
+
+/**
+ * @typedef {Record<string, any>} RangeA1 A range in A1 style coordinates.
+ * @property {number | null} [top] Top row of the range
+ * @property {number | null} [bottom] Bottom row of the range
+ * @property {number | null} [left] Left column of the range
+ * @property {number | null} [right] Right column of the range
+ * @property {boolean | null} [$top] Signifies that top is a "locked" value
+ * @property {boolean | null} [$bottom] Signifies that bottom is a "locked" value
+ * @property {boolean | null} [$left] Signifies that left is a "locked" value
+ * @property {boolean | null} [$right] Signifies that right is a "locked" value
+ */
+
+/**
+ * @typedef {Record<string, any>} ReferenceA1
+ *   A reference containing an A1 style range. See [Prefixes.md] for
+ *   documentation on how scopes work in Fx.
+ * @property {Array<string>} [context] A collection of scopes for the reference
+ * @property {string} [workbookName] A context workbook scope
+ * @property {string} [sheetName] A context sheet scope
+ * @property {RangeA1} [range] The reference's range
+ */
+
+/**
+ * @typedef {Record<string, any>} ReferenceR1C1
+ *   A reference containing a R1C1 style range. See [Prefixes.md] for
+ *   documentation on how scopes work in Fx.
+ * @property {Array<string>} [context] A collection of scopes for the reference
+ * @property {string} [workbookName] A context workbook scope
+ * @property {string} [sheetName] A context sheet scope
+ * @property {RangeR1C1} [range] The reference's range
+ */
+
+/**
+ * @typedef {Record<string, any>} ReferenceStruct
+ *   A reference containing a table slice definition. See [Prefixes.md] for
+ *   documentation on how scopes work in Fx.
+ * @property {Array<string>} [context] A collection of scopes for the reference
+ * @property {string} [workbookName] A context workbook scope
+ * @property {string} [sheetName] A context sheet scope
+ * @property {Array<string>} [sections] The sections this reference targets
+ * @property {Array<string>} [columns] The sections this reference targets
+ * @property {string} [table] The table this reference targets
+ */

package/lib/fixRanges.js

@@ -40,19 +40,19 @@ import { REF_STRUCT } from './constants.js';
  * Returns the same formula with the ranges updated. If an array of tokens was
  * supplied, then a new array is returned.
  *
- * @param {(string | Array<Object>)} formula A string (an Excel formula) or a token list that should be adjusted.
- * @param {Object} [options={}]  Options
+ * @param {(string | Array<Token>)} formula A string (an Excel formula) or a token list that should be adjusted.
+ * @param {object} [options={}]  Options
  * @param {boolean} [options.addBounds=false]  Fill in any undefined bounds of range objects. Top to 0, bottom to 1048575, left to 0, and right to 16383.
  * @param {boolean} [options.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)
+ * @returns {(string | Array<Token>)} A formula string or token list (depending on which was input)
  */
-export function fixRanges (tokens, options = { addBounds: false }) {
-  if (typeof tokens === 'string') {
-    return fixRanges(tokenize(tokens, options), options)
+export function fixRanges (formula, options = { addBounds: false }) {
+  if (typeof formula === 'string') {
+    return fixRanges(tokenize(formula, options), options)
       .map(d => d.value)
       .join('');
   }
-  if (!Array.isArray(tokens)) {
+  if (!Array.isArray(formula)) {
     throw new Error('fixRanges expects an array of tokens');
   }
   const { addBounds, r1c1, xlsx } = options;
@@ -60,7 +60,7 @@ export function fixRanges (tokens, options = { addBounds: false }) {
     throw new Error('fixRanges does not have an R1C1 mode');
   }
   let offsetSkew = 0;
-  return tokens.map(t => {
+  return formula.map(t => {
     const token = { ...t };
     if (t.loc) {
       token.loc = [ ...t.loc ];

package/lib/isType.js

@@ -12,8 +12,8 @@ import {
  * (`A1` or `A1:B2`), REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), or
  * REF_BEAM (`A:A` or `1:1`). In all other cases `false` is returned.
  *
- * @param {Object} token A token
- * @return {boolean} True if the specified token is range, False otherwise.
+ * @param {any} token A token
+ * @returns {boolean} True if the specified token is range, False otherwise.
  */
 export function isRange (token) {
   return !!token && (
@@ -30,8 +30,8 @@ export function isRange (token) {
  * REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), REF_BEAM (`A:A` or `1:1`),
  * or REF_NAMED (`myrange`). In all other cases `false` is returned.
  *
- * @param {Object} token The token
- * @return {boolean} True if the specified token is reference, False otherwise.
+ * @param {any} token The token
+ * @returns {boolean} True if the specified token is reference, False otherwise.
  */
 export function isReference (token) {
   return !!token && (
@@ -50,8 +50,8 @@ export function isReference (token) {
  * ERROR (`#VALUE!`), NUMBER (123.4), or STRING (`"lorem ipsum"`). In all other
  * cases `false` is returned.
  *
- * @param {Object} token The token
- * @return {boolean} True if the specified token is literal, False otherwise.
+ * @param {any} token The token
+ * @returns {boolean} True if the specified token is literal, False otherwise.
  */
 export function isLiteral (token) {
   return !!token && (
@@ -68,8 +68,8 @@ export function isLiteral (token) {
  * Returns `true` if the input is a token of type ERROR (`#VALUE!`). In all
  * other cases `false` is returned.
  *
- * @param {Object} token The token
- * @return {boolean} True if the specified token is error, False otherwise.
+ * @param {any} token The token
+ * @returns {boolean} True if the specified token is error, False otherwise.
  */
 export function isError (token) {
   return !!token && token.type === ERROR;
@@ -81,8 +81,8 @@ export function isError (token) {
  * Returns `true` if the input is a token of type WHITESPACE (` `) or
  * NEWLINE (`\n`). In all other cases `false` is returned.
  *
- * @param {Object} token The token
- * @return {boolean} True if the specified token is whitespace, False otherwise.
+ * @param {any} token The token
+ * @returns {boolean} True if the specified token is whitespace, False otherwise.
  */
 export function isWhitespace (token) {
   return !!token && (
@@ -97,8 +97,8 @@ export function isWhitespace (token) {
  * Returns `true` if the input is a token of type FUNCTION.
  * In all other cases `false` is returned.
  *
- * @param {Object} token The token
- * @return {boolean} True if the specified token is function, False otherwise.
+ * @param {any} token The token
+ * @returns {boolean} True if the specified token is function, False otherwise.
  */
 export function isFunction (token) {
   return !!token && token.type === FUNCTION;
@@ -108,8 +108,8 @@ export function isFunction (token) {
  * Returns `true` if the input is a token of type FX_PREFIX (leading `=` in
  * formula). In all other cases `false` is returned.
  *
- * @param {Object} token The token
- * @return {boolean} True if the specified token is effects prefix, False otherwise.
+ * @param {any} token The token
+ * @returns {boolean} True if the specified token is effects prefix, False otherwise.
  */
 export function isFxPrefix (token) {
   return !!token && token.type === FX_PREFIX;
@@ -121,8 +121,8 @@ export function isFxPrefix (token) {
  * Returns `true` if the input is a token of type OPERATOR (`+` or `:`). In all
  * other cases `false` is returned.
  *
- * @param {Object} token The token
- * @return {boolean} True if the specified token is operator, False otherwise.
+ * @param {any} token The token
+ * @returns {boolean} True if the specified token is operator, False otherwise.
  */
 export function isOperator (token) {
   return !!token && token.type === OPERATOR;

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/lexer.js

@@ -196,14 +196,14 @@ export function getTokens (fx, tokenHandlers, options = {}) {
  *
  * @see tokenTypes
  * @param {string} formula An Excel formula string (an Excel expression) or an array of tokens.
- * @param {Object} [options={}]  Options
+ * @param {object} [options={}]  Options
  * @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.negativeNumbers=true]  Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1` (alternatively these will be unary operations in the tree).
  * @param {boolean} [options.r1c1=false]  Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.
  * @param {boolean} [options.withLocation=true]  Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
  * @param {boolean} [options.mergeRefs=true]  Should ranges be returned as whole references (`Sheet1!A1:B2`) or as separate tokens for each part: (`Sheet1`,`!`,`A1`,`:`,`B2`). This is the same as calling [`mergeRefTokens`](#mergeRefTokens)
  * @param {boolean} [options.xlsx=false]  Enables a `[1]Sheet1!A1` or `[1]!name` syntax form for external workbooks found only in XLSX files.
- * @return {Array<Object>} An AST of nodes
+ * @returns {Array<Token>} An AST of nodes
  */
 export function tokenize (formula, options = {}) {
   return getTokens(formula, lexers, options);

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/mergeRefTokens.js

@@ -63,8 +63,8 @@ const matcher = (tokens, currNode, anchorIndex, index = 0) => {
  * as whole references (`Sheet1!A1:B2`) rather than separate tokens for each
  * part: (`Sheet1`,`!`,`A1`,`:`,`B2`).
  *
- * @param {Array<Object>} tokenlist An array of tokens (from `tokenize()`)
- * @return {Array} A new list of tokens with range parts merged.
+ * @param {Array<Token>} tokenlist An array of tokens (from `tokenize()`)
+ * @returns {Array<Token>} A new list of tokens with range parts merged.
  */
 export function mergeRefTokens (tokenlist) {
   const finalTokens = [];

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

@@ -478,8 +478,8 @@ prefix('{', function () {
  * [AST_format.md](./AST_format.md)
  *
  * @see nodeTypes
- * @param {(string | Array<Object>)} formula An Excel formula string (an Excel expression) or an array of tokens.
- * @param {Object} [options={}]  Options
+ * @param {(string | Array<Token>)} formula An Excel formula string (an Excel expression) or an array of tokens.
+ * @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.negativeNumbers=true]  Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1` (alternatively these will be unary operations in the tree).
@@ -488,18 +488,18 @@ prefix('{', function () {
  * @param {boolean} [options.r1c1=false]  Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.
  * @param {boolean} [options.withLocation=false]  Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
  * @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} An AST of nodes
+ * @returns {object} An AST of nodes
  */
-export function parse (source, options) {
-  if (typeof source === 'string') {
-    tokens = tokenize(source, {
+export function parse (formula, options) {
+  if (typeof formula === 'string') {
+    tokens = tokenize(formula, {
       withLocation: false,
       ...options,
       mergeRefs: true
     });
   }
-  else if (Array.isArray(source)) {
-    tokens = source;
+  else if (Array.isArray(formula)) {
+    tokens = formula;
   }
   else {
     throw new Error('Parse requires a string or array of tokens.');