@borgar/fx 4.13.0 → 5.0.0

package/lib/astTypes.js

@@ -1,96 +0,0 @@
-/* eslint-disable jsdoc/require-property-description */
-
-/**
- * @typedef {number[]} SourceLocation
- */
-
-/**
- * @typedef {Node} Identifier
- * @property {"Identifier"} type
- * @property {SourceLocation} [loc]
- * @property {string} name
- */
-
-/**
- * @typedef {Node} ReferenceIdentifier
- * @property {"ReferenceIdentifier"} type
- * @property {SourceLocation} [loc]
- * @property {string} value
- * @property {"name" | "range" | "beam" | "table"} kind
- */
-
-/**
- * @typedef {Node} Literal
- * @property {"Literal"} type
- * @property {SourceLocation} [loc]
- * @property {string} raw
- * @property {string | number | boolean} value
- */
-
-/**
- * @typedef {Node} ErrorLiteral
- * @property {"ErrorLiteral"} type
- * @property {SourceLocation} [loc]
- * @property {string} raw
- * @property {string} value
- */
-
-/**
- * @typedef {Node} UnaryExpression
- * @property {"UnaryExpression"} type
- * @property {SourceLocation} [loc]
- * @property {"+" | "-" | "%" | "#" | "@"} operator
- * @property {AstExpression[]} arguments
- */
-
-/**
- * @typedef {Node} BinaryExpression
- * @property {"BinaryExpression"} type
- * @property {SourceLocation} [loc]
- * @property {"=" | "<" | ">" | "<=" | ">=" | "<>" | "-" | "+" | "*" | "/" | "^" | ":" | " " | "," | "&"} operator
- * @property {AstExpression[]} arguments
- */
-
-/**
- * @typedef {Node} CallExpression
- * @property {"CallExpression"} type
- * @property {SourceLocation} [loc]
- * @property {Identifier} callee
- * @property {AstExpression[]} arguments
- */
-
-// FIXME: the awkward naming is because tooling fails, fix tooling :)
-/**
- * @typedef {Node} MatrixExpression
- * @property {"ArrayExpression"} type
- * @property {SourceLocation} [loc]
- * @property {Array<Array<ReferenceIdentifier | Literal | ErrorLiteral | CallExpression>>} arguments
- */
-
-/**
- * @typedef {Node} LambdaExpression
- * @property {"LambdaExpression"} type
- * @property {SourceLocation} [loc]
- * @property {Identifier[]} params
- * @property {null | AstExpression} body
- */
-
-/**
- * @typedef {Node} LetExpression
- * @property {"LetExpression"} type
- * @property {SourceLocation} [loc]
- * @property {LetDeclarator[]} declarations
- * @property {null | AstExpression} body
- */
-
-/**
- * @typedef {Node} LetDeclarator
- * @property {"LetDeclarator"} type
- * @property {SourceLocation} [loc]
- * @property {Identifier} id
- * @property {null | AstExpression} init
- */
-
-/**
- * @typedef {ReferenceIdentifier | Literal | ErrorLiteral | UnaryExpression | BinaryExpression | CallExpression | MatrixExpression | LambdaExpression | LetExpression} AstExpression
- */

package/lib/extraTypes.js

@@ -1,74 +0,0 @@
-/**
- * @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
- * @property {"head" | "tail" | "both"} [trim] Should empty rows and columns at the top/left or bottom/right be discarded when range is read?
- */
-
-/**
- * @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

@@ -1,104 +0,0 @@
-import { isRange } from './isType.js';
-import { parseA1Ref, stringifyA1Ref, addA1RangeBounds } from './a1.js';
-import { parseStructRef } from './parseStructRef.js';
-import { stringifyStructRef } from './stringifyStructRef.js';
-import { tokenize } from './lexer.js';
-import { REF_STRUCT } from './constants.js';
-
-// There is no R1C1 counterpart to this. This is because without an anchor cell
-// it is impossible to determine if a relative+absolute range (R[1]C[1]:R5C5)
-// needs to be flipped or not. The solution is to convert to A1 first:
-// translateToRC(fixRanges(translateToA1(...)))
-
-/**
- * Normalizes A1 style ranges and structured references in a formula or list of
- * tokens.
- * 
- * It ensures that that the top and left coordinates of an A1 range are on the
- * left-hand side of a colon operator:
- *
- * `B2:A1` → `A1:B2`  
- * `1:A1` → `A1:1`  
- * `A:A1` → `A1:A`  
- * `B:A` → `A:B`  
- * `2:1` → `1:2`  
- * `A1:A1` → `A1`  
- *
- * When `{ addBounds: true }` is passed as an option, the missing bounds are
- * also added. This can be done to ensure Excel compatible ranges. The fixes
- * then additionally include:
- *
- * `1:A1` → `A1:1` → `1:1`  
- * `A:A1` → `A1:A` → `A:A`  
- * `A1:A` → `A:A`  
- * `A1:1` → `A:1`  
- * `B2:B` → `B2:1048576`  
- * `B2:2` → `B2:XFD2`  
- *
- * Structured ranges are normalized cleaned up to have consistent order and
- * capitalization of sections as well as removing redundant ones.
- *
- * Returns the same formula with the ranges updated. If an array of tokens was
- * supplied, then a new array is returned.
- *
- * @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)
- * @param {boolean} [options.thisRow=false]  Enforces using the `[#This Row]` instead of the `@` shorthand when serializing structured ranges.
- * @returns {(string | Array<Token>)} A formula string or token list (depending on which was input)
- */
-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(formula)) {
-    throw new Error('fixRanges expects an array of tokens');
-  }
-  const { addBounds, r1c1, xlsx, thisRow } = options;
-  if (r1c1) {
-    throw new Error('fixRanges does not have an R1C1 mode');
-  }
-  let offsetSkew = 0;
-  return formula.map(t => {
-    const token = { ...t };
-    if (t.loc) {
-      token.loc = [ ...t.loc ];
-    }
-    let offsetDelta = 0;
-    if (token.type === REF_STRUCT) {
-      const sref = parseStructRef(token.value, { xlsx });
-      const newValue = stringifyStructRef(sref, { xlsx, thisRow });
-      offsetDelta = newValue.length - token.value.length;
-      token.value = newValue;
-    }
-    else if (isRange(token)) {
-      const ref = parseA1Ref(token.value, { xlsx, allowTernary: true });
-      const range = ref.range;
-      // fill missing dimensions?
-      if (addBounds) {
-        addA1RangeBounds(range);
-      }
-      const newValue = stringifyA1Ref(ref, { xlsx });
-      offsetDelta = newValue.length - token.value.length;
-      token.value = newValue;
-    }
-    // ensure that positioning is still correct
-    if (offsetSkew || offsetDelta) {
-      if (token.loc) {
-        token.loc[0] += offsetSkew;
-      }
-      offsetSkew += offsetDelta;
-      if (token.loc) {
-        token.loc[1] += offsetSkew;
-      }
-    }
-    else {
-      offsetSkew += offsetDelta;
-    }
-    return token;
-  });
-}
-

package/lib/fixRanges.spec.js

@@ -1,171 +0,0 @@
-import { test, Test } from 'tape';
-import { tokenize } from './lexer.js';
-import { addTokenMeta } from './addTokenMeta.js';
-import { fixRanges } from './fixRanges.js';
-import { FUNCTION, FX_PREFIX, OPERATOR, REF_RANGE, REF_STRUCT, REF_TERNARY } from './constants.js';
-
-Test.prototype.isFixed = function (expr, expected, options = {}) {
-  const result = fixRanges(expr, options);
-  this.is(result, expected,
-    `\x1b[36m${expr} → ${expected} \x1b[37mopts=${JSON.stringify(options)}\x1b[0m`);
-};
-
-test('fixRanges basics', t => {
-  const fx = '=SUM([wb]Sheet1!B2:A1)';
-  t.throws(() => fixRanges(123), 'throws on non arrays (number)');
-  t.throws(() => fixRanges(null), 'throws on non arrays (null)');
-  const tokens = addTokenMeta(tokenize(fx, { mergeRefs: true }));
-  tokens[3].foo = 'bar';
-  const fixedTokens = fixRanges(tokens, { debug: 0 });
-  t.ok(tokens !== fixedTokens, 'emits a new array instance');
-  t.ok(tokens[3] !== fixedTokens[3], 'does not mutate existing range tokens');
-  t.deepEqual(tokens[3], {
-    type: REF_RANGE,
-    value: '[wb]Sheet1!B2:A1',
-    index: 3,
-    depth: 1,
-    groupId: 'fxg1',
-    foo: 'bar'
-  }, 'keeps meta (pre-fix range token)');
-  t.deepEqual(fixedTokens[3], {
-    type: REF_RANGE,
-    value: '[wb]Sheet1!A1:B2',
-    index: 3,
-    depth: 1,
-    groupId: 'fxg1',
-    foo: 'bar'
-  }, 'keeps meta (post-fix range token)');
-  const tokensWithRanges = tokenize(
-    '=SUM(B2:A,table[[#This Row],[Foo]])',
-    { withLocation: true, mergeRefs: true, allowTernary: true }
-  );
-  t.deepEqual(fixRanges(tokensWithRanges, { addBounds: true }), [
-    { type: FX_PREFIX, value: '=', loc: [ 0, 1 ] },
-    { type: FUNCTION, value: 'SUM', loc: [ 1, 4 ] },
-    { type: OPERATOR, value: '(', loc: [ 4, 5 ] },
-    { type: REF_TERNARY, value: 'A2:B1048576', loc: [ 5, 16 ] },
-    { type: OPERATOR, value: ',', loc: [ 16, 17 ] },
-    { type: REF_STRUCT, value: 'table[@Foo]', loc: [ 17, 28 ] },
-    { type: OPERATOR, value: ')', loc: [ 28, 29 ] }
-  ], 'updates token source location information');
-  t.end();
-});
-
-test('fixRanges A1', t => {
-  const opt = { allowTernary: true };
-  // doesn't mess with things that it doesn't have to
-  t.isFixed('=A1', '=A1', opt);
-  t.isFixed('=ZZ123', '=ZZ123', opt);
-  t.isFixed('=A1:B2', '=A1:B2', opt);
-  t.isFixed('=B3:OFFSET(A1,10,10)', '=B3:OFFSET(A1,10,10)', opt);
-  t.isFixed('=A:B', '=A:B', opt);
-  t.isFixed('=C:C', '=C:C', opt);
-  t.isFixed('=3:6', '=3:6', opt);
-  t.isFixed('=3:3', '=3:3', opt);
-  // redundancy
-  t.isFixed('=A1:$A$1', '=A1:$A$1', opt);
-  t.isFixed('=A1:A1', '=A1', opt);
-  // lowercase to uppercase
-  t.isFixed('=a1', '=A1', opt);
-  t.isFixed('=zz123', '=ZZ123', opt);
-  t.isFixed('=a1:b2', '=A1:B2', opt);
-  // flipped rects
-  t.isFixed('=B2:A1', '=A1:B2', opt);
-  t.isFixed('=$B$2:$A$1', '=$A$1:$B$2', opt);
-  // flipped beams
-  t.isFixed('=C:A', '=A:C', opt);
-  t.isFixed('=$D:B', '=B:$D', opt);
-  t.isFixed('=10:1', '=1:10', opt);
-  t.isFixed('=$5:3', '=3:$5', opt);
-  // flipped partials - bottom
-  t.isFixed('=A:A1', '=A1:A', opt);
-  t.isFixed('=A:A$1', '=A$1:A', opt);
-  // flipped partials - right
-  t.isFixed('=1:A1', '=A1:1', opt);
-  // $1:$A1 is rather counter intuitive case:
-  //   This range is parsed as { left=null, top=$1, right=$A, bottom=1 } but,
-  //   because left is null, right and left are flipped around, making this
-  //   end up as { left=$A, top=$1, right=null, bottom=1 } which serializes
-  //   as $A$1:1
-  t.isFixed('=$1:$A1', '=$A$1:1', opt);
-  t.end();
-});
-
-test('fixRanges A1 addBounds', t => {
-  const opt = { allowTernary: true, addBounds: true };
-  t.isFixed('=B3:OFFSET(A1,10,10)', '=B3:OFFSET(A1,10,10)', opt);
-  t.isFixed('=A:A', '=A:A', opt);
-  t.isFixed('=A:A1', '=A:A', opt);
-  t.isFixed('=A:A$1', '=A:A', opt);
-  t.isFixed('=A:$A$1', '=A:$A', opt);
-  t.isFixed('=A.:A', '=A.:A', opt);
-  // partials - bottom
-  t.isFixed('=A1:A', '=A:A', opt);
-  t.isFixed('=A1:Z', '=A:Z', opt);
-  t.isFixed('=A:A1', '=A:A', opt);
-  t.isFixed('=$A1:A', '=$A:A', opt);
-  t.isFixed('=A$1:A', '=A:A', opt);
-  t.isFixed('=A1:$A', '=A:$A', opt);
-  t.isFixed('=A2:A', '=A2:A1048576', opt);
-  t.isFixed('=B2:B', '=B2:B1048576', opt);
-  t.isFixed('=A:A2', '=A2:A1048576', opt);
-  t.isFixed('=B:B2', '=B2:B1048576', opt);
-  t.isFixed('=B.:.B2', '=B2.:.B1048576', opt);
-  // flipped partials - bottom
-  t.isFixed('=A1:1', '=1:1', opt);
-  t.isFixed('=A1:4', '=1:4', opt);
-  t.isFixed('=1:A1', '=1:1', opt);
-  t.isFixed('=$A1:1', '=1:1', opt);
-  t.isFixed('=A$1:1', '=$1:1', opt);
-  t.isFixed('=A1:$1', '=1:$1', opt);
-  t.isFixed('=B1:1', '=B1:XFD1', opt);
-  t.isFixed('=1:B1', '=B1:XFD1', opt);
-  t.isFixed('=B2:20', '=B2:XFD20', opt);
-  t.isFixed('=2:B20', '=B2:XFD20', opt);
-  t.isFixed('=2:.B20', '=B2:.XFD20', opt);
-  t.end();
-});
-
-test('fixRanges structured references', t => {
-  t.isFixed('=Table1[[#This Row],[Foo]]', '=Table1[@Foo]');
-  t.isFixed('=[[#This Row],[s:s]]', '=[@[s:s]]');
-  t.isFixed('=Table1[[#Totals],col name:Foo]', '=Table1[[#Totals],[col name]:[Foo]]');
-  t.isFixed('[[#data],[#headers]]', '[[#Headers],[#Data]]');
-  t.isFixed('[[#headers],[#data]]', '[[#Headers],[#Data]]');
-  t.isFixed('[[#totals],[#data]]', '[[#Data],[#Totals]]');
-  t.isFixed('[ [#totals], [#data] ]', '[[#Data],[#Totals]]');
-  t.isFixed('[[#data],[#totals]]', '[[#Data],[#Totals]]');
-  t.isFixed('[[#all],foo:bar]', '[[#All],[foo]:[bar]]');
-  t.isFixed('[[#all],[#all],[#all],[#all],[ColumnName]]', '[[#All],[ColumnName]]');
-  t.isFixed('[@[foo]:bar]', '[@[foo]:[bar]]');
-  t.isFixed('[@foo bar]', '[@[foo bar]]');
-  // Care must be taken with spaces in column headers.
-  // Excel considers refs only valid if they match the column name
-  // but the parser does not know the names, so it must preserve
-  // leading/trailing whitespace.
-  t.isFixed('[ @[foo bar] ]', '[@[foo bar]]');
-  t.isFixed('[ @[ foo bar ] ]', '[@[ foo bar ]]');
-  t.isFixed('[ @foo bar ]', '[@[foo bar ]]');
-  t.isFixed('[@ foo bar]', '[@[ foo bar]]');
-  t.isFixed('[ @ foo bar ]', '[@[ foo bar ]]');
-  t.end();
-});
-
-test('fixRanges works with xlsx mode', t => {
-  // should not mess with invalid ranges in normal mode
-  t.isFixed("='[Workbook]'!Table[Column]", "='[Workbook]'!Table[Column]");
-  t.isFixed('=[Workbook]!Table[Column]', '=[Workbook]!Table[Column]');
-  t.isFixed("='[Foo]'!A1", "='[Foo]'!A1");
-  t.isFixed('=[Foo]!A1', '=[Foo]!A1');
-  // should fix things in xlsx mode
-  const opts = { xlsx: true };
-  t.isFixed("='[Workbook]'!Table[Column]", '=[Workbook]!Table[Column]', opts);
-  t.isFixed('=[Workbook]!Table[Column]', '=[Workbook]!Table[Column]', opts);
-  t.isFixed('=[Lorem Ipsum]!Table[Column]', "='[Lorem Ipsum]'!Table[Column]", opts);
-  t.isFixed("='[Foo]'!A1", '=[Foo]!A1', opts);
-  t.isFixed('=[Foo]Bar!A1', '=[Foo]Bar!A1', opts);
-  t.isFixed('=[Foo Bar]Baz!A1', "='[Foo Bar]Baz'!A1", opts);
-  t.isFixed('=[Foo]!A1', '=[Foo]!A1', opts);
-  t.isFixed('=[Lorem Ipsum]!A1', "='[Lorem Ipsum]'!A1", opts);
-  t.end();
-});

package/lib/fromCol.spec.js

@@ -1,11 +0,0 @@
-import { test } from 'tape';
-import { fromCol } from './fromCol.js';
-
-test('fromCol parses column id strings to numbers', t => {
-  t.is(fromCol('a'), 0);
-  t.is(fromCol('A'), 0);
-  t.is(fromCol('AA'), 26);
-  t.is(fromCol('zz'), 701);
-  t.is(fromCol('ZZZ'), 18277);
-  t.end();
-});

package/lib/index.js

@@ -1,134 +0,0 @@
-export { tokenize } from './lexer.js';
-export { parse } from './parser.js';
-export { addTokenMeta } from './addTokenMeta.js';
-export { translateToR1C1, translateToA1 } from './translate.js';
-export { MAX_COLS, MAX_ROWS } from './constants.js';
-export { mergeRefTokens } from './mergeRefTokens.js';
-export { fixRanges } from './fixRanges.js';
-export {
-  isError,
-  isFunction,
-  isFxPrefix,
-  isLiteral,
-  isOperator,
-  isRange,
-  isReference,
-  isWhitespace
-} from './isType.js';
-
-export { fromCol } from './fromCol.js';
-export { toCol } from './toCol.js';
-
-export {
-  parseA1Ref,
-  stringifyA1Ref,
-  addA1RangeBounds
-} from './a1.js';
-
-export {
-  parseR1C1Ref,
-  stringifyR1C1Ref
-} from './rc.js';
-
-export { stringifyStructRef } from './stringifyStructRef.js';
-export { parseStructRef } from './parseStructRef.js';
-
-import {
-  // token types
-  OPERATOR,
-  BOOLEAN,
-  ERROR,
-  NUMBER,
-  FUNCTION,
-  NEWLINE,
-  WHITESPACE,
-  STRING,
-  CONTEXT,
-  CONTEXT_QUOTE,
-  REF_RANGE,
-  REF_BEAM,
-  REF_TERNARY,
-  REF_NAMED,
-  REF_STRUCT,
-  FX_PREFIX,
-  UNKNOWN,
-  // AST types
-  UNARY,
-  BINARY,
-  REFERENCE,
-  LITERAL,
-  ERROR_LITERAL,
-  CALL,
-  ARRAY,
-  IDENTIFIER
-} from './constants.js';
-
-/**
- * A dictionary of the types used to identify token variants.
- *
- * @readonly
- * @constant {Object<string>} tokenTypes
- * @property {string} OPERATOR - Newline (`\n`)
- * @property {string} BOOLEAN - Boolean literal (`TRUE`)
- * @property {string} ERROR - Error literal (`#VALUE!`)
- * @property {string} NUMBER - Number literal (`123.4`, `-1.5e+2`)
- * @property {string} FUNCTION - Function name (`SUM`)
- * @property {string} NEWLINE - Newline character (`\n`)
- * @property {string} WHITESPACE - Whitespace character sequence (` `)
- * @property {string} STRING - String literal (`"Lorem ipsum"`)
- * @property {string} CONTEXT - Reference context ([Workbook.xlsx]Sheet1)
- * @property {string} CONTEXT_QUOTE - Quoted reference context (`'[My workbook.xlsx]Sheet1'`)
- * @property {string} REF_RANGE - A range identifier (`A1`)
- * @property {string} REF_BEAM - A range "beam" identifier (`A:A` or `1:1`)
- * @property {string} REF_TERNARY - A ternary range identifier (`B2:B`)
- * @property {string} REF_NAMED - A name / named range identifier (`income`)
- * @property {string} REF_STRUCT - A structured reference identifier (`table[[Column1]:[Column2]]`)
- * @property {string} FX_PREFIX - A leading equals sign at the start of a formula (`=`)
- * @property {string} UNKNOWN - Any unidentifiable range of characters.
- * @see tokenize
- */
-export const tokenTypes = Object.freeze({
-  OPERATOR,
-  BOOLEAN,
-  ERROR,
-  NUMBER,
-  FUNCTION,
-  NEWLINE,
-  WHITESPACE,
-  STRING,
-  CONTEXT,
-  CONTEXT_QUOTE,
-  REF_RANGE,
-  REF_BEAM,
-  REF_TERNARY,
-  REF_NAMED,
-  REF_STRUCT,
-  FX_PREFIX,
-  UNKNOWN
-});
-
-/**
- * A dictionary of the types used to identify AST node variants.
- *
- * @readonly
- * @constant {Object<string>} nodeTypes
- * @property {string} UNARY - A unary operation (`10%`)
- * @property {string} BINARY - A binary operation (`10+10`)
- * @property {string} REFERENCE - A range identifier (`A1`)
- * @property {string} LITERAL - A literal (number, string, or boolean) (`123`, `"foo"`, `false`)
- * @property {string} ERROR - An error literal (`#VALUE!`)
- * @property {string} CALL - A function call expression (`SUM(1,2)`)
- * @property {string} ARRAY - An array expression (`{1,2;3,4}`)
- * @property {string} IDENTIFIER - A function name identifier (`SUM`)
- * @see parse
- */
-export const nodeTypes = Object.freeze({
-  UNARY,
-  BINARY,
-  REFERENCE,
-  LITERAL,
-  ERROR: ERROR_LITERAL,
-  CALL,
-  ARRAY,
-  IDENTIFIER
-});

package/lib/index.spec.js

@@ -1,67 +0,0 @@
-import { test } from 'tape';
-
-import {
-  addA1RangeBounds,
-  addTokenMeta,
-  fixRanges,
-  fromCol,
-  isError,
-  isFunction,
-  isFxPrefix,
-  isLiteral,
-  isOperator,
-  isRange,
-  isReference,
-  isWhitespace,
-  mergeRefTokens,
-  nodeTypes,
-  parse,
-  parseA1Ref,
-  parseR1C1Ref,
-  parseStructRef,
-  stringifyA1Ref,
-  stringifyR1C1Ref,
-  stringifyStructRef,
-  toCol,
-  tokenize,
-  tokenTypes,
-  translateToA1,
-  translateToR1C1
-} from './index.js';
-
-// What happens when B2:A1 -> should work!
-test('fx main interface', t => {
-  t.ok(typeof addA1RangeBounds === 'function', 'addA1RangeBounds exists');
-  t.ok(typeof addTokenMeta === 'function', 'addTokenMeta exists');
-  t.ok(typeof fixRanges === 'function', 'fixRanges exists');
-
-  t.ok(typeof fromCol === 'function', 'fromCol exists');
-
-  t.ok(typeof isError === 'function', 'isError exists');
-  t.ok(typeof isFunction === 'function', 'isFunction exists');
-  t.ok(typeof isFxPrefix === 'function', 'isFxPrefix exists');
-  t.ok(typeof isLiteral === 'function', 'isLiteral exists');
-  t.ok(typeof isOperator === 'function', 'isOperator exists');
-  t.ok(typeof isRange === 'function', 'isRange exists');
-  t.ok(typeof isReference === 'function', 'isReference exists');
-  t.ok(typeof isWhitespace === 'function', 'isWhitespace exists');
-
-  t.ok(typeof mergeRefTokens === 'function', 'mergeRefTokens exists');
-  t.ok(typeof parse === 'function', 'parse exists');
-  t.ok(typeof parseA1Ref === 'function', 'parseA1Ref exists');
-  t.ok(typeof parseR1C1Ref === 'function', 'parseR1C1Ref exists');
-  t.ok(typeof parseStructRef === 'function', 'parseStructRef exists');
-  t.ok(typeof stringifyA1Ref === 'function', 'stringifyA1Ref exists');
-  t.ok(typeof stringifyR1C1Ref === 'function', 'stringifyR1C1Ref exists');
-  t.ok(typeof stringifyStructRef === 'function', 'stringifyStructRef exists');
-  t.ok(typeof toCol === 'function', 'toCol exists');
-  t.ok(typeof tokenize === 'function', 'tokenize exists');
-  t.ok(typeof translateToA1 === 'function', 'translateToA1 exists');
-  t.ok(typeof translateToR1C1 === 'function', 'translateToR1C1 exists');
-
-  t.ok(typeof nodeTypes === 'object', 'nodeTypes exists');
-  t.ok(typeof tokenTypes === 'object', 'tokenTypes exists');
-
-  t.end();
-});
-