{"version":3,"sources":["../lib/index.ts","../lib/constants.ts","../lib/mergeRefTokens.ts","../lib/lexers/lexError.ts","../lib/lexers/lexRangeTrim.ts","../lib/lexers/lexOperator.ts","../lib/lexers/lexBoolean.ts","../lib/lexers/lexNewLine.ts","../lib/lexers/lexWhitespace.ts","../lib/lexers/lexString.ts","../lib/lexers/lexContext.ts","../lib/lexers/advRangeOp.ts","../lib/lexers/canEndRange.ts","../lib/lexers/lexRangeA1.ts","../lib/lexers/lexRangeR1C1.ts","../lib/lexers/lexRange.ts","../lib/parseSRange.ts","../lib/lexers/lexStructured.ts","../lib/lexers/lexNumber.ts","../lib/lexers/lexNamed.ts","../lib/lexers/lexRefOp.ts","../lib/lexers/lexNameFuncCntx.ts","../lib/lexers/sets.ts","../lib/isRCTokenValue.ts","../lib/tokenize.ts","../lib/isType.ts","../lib/parse.ts","../lib/stringifyPrefix.ts","../lib/a1.ts","../lib/stringifyR1C1Range.ts","../lib/stringifyR1C1Ref.ts","../lib/parseA1Range.ts","../lib/stringifyTokens.ts","../lib/cloneToken.ts","../lib/parseRef.ts","../lib/translateToR1C1.ts","../lib/toCol.ts","../lib/stringifyA1Range.ts","../lib/stringifyA1Ref.ts","../lib/parseR1C1Range.ts","../lib/parseR1C1Ref.ts","../lib/translateToA1.ts","../lib/parseA1Ref.ts","../lib/addA1RangeBounds.ts","../lib/parseStructRef.ts","../lib/stringifyStructRef.ts","../lib/fixRanges.ts","../lib/isNodeType.ts","../lib/fromCol.ts","../lib/tokenTypes.ts","../lib/nodeTypes.ts"],"sourcesContent":["/**\n * A tokenizer, parser, and other utilities to work with Excel formula code.\n *\n * The base entry-point methods expect and return the variant of references that uses contexts.\n * If you are using xlsx files or otherwise want to work with the xlsx-file variant of references\n * you should use the {@link fx/xlsx} variant methods.\n *\n * See [Prefixes.md](./Prefixes.md) for documentation on how scopes work in Fx.\n *\n * @packageDocumentation\n * @module fx\n */\n\nexport { tokenize, type OptsTokenize } from './tokenize.ts';\nexport { parse, type OptsParse } from './parse.ts';\nexport { translateFormulaToR1C1, translateTokensToR1C1, type OptsTranslateToR1C1 } from './translateToR1C1.ts';\nexport {\n  translateFormulaToA1, type OptsTranslateFormulaToA1,\n  translateTokensToA1, type OptsTranslateTokensToA1\n} from './translateToA1.ts';\nexport { MAX_COLS, MAX_ROWS } from './constants.ts';\nexport { mergeRefTokens } from './mergeRefTokens.ts';\nexport { fixTokenRanges, fixFormulaRanges, type OptsFixRanges } from './fixRanges.ts';\nexport {\n  isError,\n  isFunction,\n  isFxPrefix,\n  isLiteral,\n  isOperator,\n  isRange,\n  isReference,\n  isWhitespace\n} from './isType.ts';\nexport {\n  isArrayNode,\n  isBinaryNode,\n  isCallNode,\n  isErrorNode,\n  isExpressionNode,\n  isIdentifierNode,\n  isLambdaNode,\n  isLetDeclaratorNode,\n  isLetNode,\n  isLiteralNode,\n  isReferenceNode,\n  isUnaryNode\n} from './isNodeType.ts';\nexport { addA1RangeBounds } from './addA1RangeBounds.ts';\nexport { toCol } from './toCol.ts';\nexport { fromCol } from './fromCol.ts';\nexport { parseA1Range } from './parseA1Range.ts';\nexport { parseA1Ref, type OptsParseA1Ref } from './parseA1Ref.ts';\nexport { parseR1C1Range } from './parseR1C1Range.ts';\nexport { parseR1C1Ref, type OptsParseR1C1Ref } from './parseR1C1Ref.ts';\nexport { parseStructRef } from './parseStructRef.ts';\nexport { stringifyA1Ref } from './stringifyA1Ref.ts';\nexport { stringifyR1C1Ref } from './stringifyR1C1Ref.ts';\nexport { stringifyStructRef, type OptsStringifyStructRef } from './stringifyStructRef.ts';\nexport { stringifyTokens } from './stringifyTokens.ts';\nexport type {\n  RangeA1,\n  RangeR1C1,\n  Token,\n  TokenEnhanced,\n  ReferenceA1,\n  ReferenceA1Xlsx,\n  ReferenceR1C1,\n  ReferenceR1C1Xlsx,\n  ReferenceStruct,\n  ReferenceStructXlsx,\n  ReferenceName,\n  ReferenceNameXlsx\n} from './types.ts';\nexport type * from './astTypes.ts';\nexport { tokenTypes } from './tokenTypes.ts';\nexport { nodeTypes } from './nodeTypes.ts';\n","export const OPERATOR = 'operator';\nexport const OPERATOR_TRIM = 'operator-trim'; // internal only\nexport const BOOLEAN = 'bool';\nexport const ERROR = 'error';\nexport const NUMBER = 'number';\nexport const FUNCTION = 'func';\nexport const NEWLINE = 'newline';\nexport const WHITESPACE = 'whitespace';\nexport const STRING = 'string';\nexport const CONTEXT_QUOTE = 'context_quote';\nexport const CONTEXT = 'context';\nexport const REF_RANGE = 'range';\nexport const REF_BEAM = 'range_beam';\nexport const REF_TERNARY = 'range_ternary';\nexport const REF_NAMED = 'range_named';\nexport const REF_STRUCT = 'structured';\n// TODO: in future, we should type the difference between A1:B1 (REF_RANGE) and\n//       A1 (REF_CELL) but this will require a major version bump.\nexport const REF_CELL = 'cell'; // internal only\nexport const FX_PREFIX = 'fx_prefix';\nexport const UNKNOWN = 'unknown';\n\nexport const UNARY = 'UnaryExpression';\nexport const BINARY = 'BinaryExpression';\nexport const REFERENCE = 'ReferenceIdentifier';\nexport const LITERAL = 'Literal';\nexport const ERROR_LITERAL = 'ErrorLiteral';\nexport const CALL = 'CallExpression';\nexport const LAMBDA = 'LambdaExpression';\nexport const LET = 'LetExpression';\nexport const ARRAY = 'ArrayExpression';\nexport const IDENTIFIER = 'Identifier';\nexport const LET_DECL = 'LetDeclarator';\n\n/** The maximum number of columns a spreadsheet reference may hold (16383). */\nexport const MAX_COLS = (2 ** 14) - 1;\n\n/** The maximum number of rows a spreadsheet reference may hold (1048575). */\nexport const MAX_ROWS = (2 ** 20) - 1;\n","import { CONTEXT, CONTEXT_QUOTE, REF_RANGE, REF_NAMED, REF_BEAM, REF_TERNARY, OPERATOR, REF_STRUCT, REF_CELL } from './constants.ts';\nimport type { Token } from './types.ts';\n\nconst END = '$';\n\nconst validRunsMerge = [\n  [ REF_CELL, ':', REF_CELL ],\n  [ REF_CELL, '.:', REF_CELL ],\n  [ REF_CELL, ':.', REF_CELL ],\n  [ REF_CELL, '.:.', REF_CELL ],\n  [ REF_RANGE ],\n  [ REF_BEAM ],\n  [ REF_TERNARY ],\n  [ CONTEXT, '!', REF_CELL, ':', REF_CELL ],\n  [ CONTEXT, '!', REF_CELL, '.:', REF_CELL ],\n  [ CONTEXT, '!', REF_CELL, ':.', REF_CELL ],\n  [ CONTEXT, '!', REF_CELL, '.:.', REF_CELL ],\n  [ CONTEXT, '!', REF_CELL ],\n  [ CONTEXT, '!', REF_RANGE ],\n  [ CONTEXT, '!', REF_BEAM ],\n  [ CONTEXT, '!', REF_TERNARY ],\n  [ CONTEXT_QUOTE, '!', REF_CELL, ':', REF_CELL ],\n  [ CONTEXT_QUOTE, '!', REF_CELL, '.:', REF_CELL ],\n  [ CONTEXT_QUOTE, '!', REF_CELL, ':.', REF_CELL ],\n  [ CONTEXT_QUOTE, '!', REF_CELL, '.:.', REF_CELL ],\n  [ CONTEXT_QUOTE, '!', REF_CELL ],\n  [ CONTEXT_QUOTE, '!', REF_RANGE ],\n  [ CONTEXT_QUOTE, '!', REF_BEAM ],\n  [ CONTEXT_QUOTE, '!', REF_TERNARY ],\n  [ REF_NAMED ],\n  [ CONTEXT, '!', REF_NAMED ],\n  [ CONTEXT_QUOTE, '!', REF_NAMED ],\n  [ REF_STRUCT ],\n  [ REF_NAMED, REF_STRUCT ],\n  [ CONTEXT, '!', REF_NAMED, REF_STRUCT ],\n  [ CONTEXT_QUOTE, '!', REF_NAMED, REF_STRUCT ]\n];\n\ntype TypeNode = {\n  [key: string]: TypeNode | boolean;\n};\n\n// valid token runs are converted to a tree structure\nconst refPartsTree: TypeNode = {};\nfunction packList (f: string[], node: TypeNode) {\n  if (f.length) {\n    const key = f[0];\n    if (!node[key]) { node[key] = {}; }\n    packList(f.slice(1), node[key] as TypeNode);\n  }\n  else {\n    node[END] = true;\n  }\n}\nvalidRunsMerge.forEach(run => packList(run.concat().reverse(), refPartsTree));\n\n// attempt to match a backwards run of tokens from a given point\n// to a path in the tree\nconst matcher = (tokens: Token[], currNode, anchorIndex, index = 0) => {\n  let i = index;\n  let node = currNode;\n  const max = tokens.length - index;\n  // keep walking as long as the next backward token matches a child key\n  while (i <= max) {\n    const token = tokens[anchorIndex - i];\n    if (token) {\n      const value = token.value;\n      let key = (token.type === OPERATOR) ? value : token.type;\n      // we need to prevent merging [\"A1:B2\" \":\" \"C3\"] as a range is only\n      // allowed to contain a single \":\" operator even if \"A1:B2:C3\" is\n      // valid Excel syntax\n      if (key === REF_RANGE && !value.includes(':')) {\n        key = REF_CELL;\n      }\n      if (key in node) {\n        node = node[key];\n        i += 1;\n        continue;\n      }\n    }\n    // can't advance further; accept only if current node is a terminal\n    return node[END] ? i : 0;\n  }\n};\n\n/**\n * Merges context with reference tokens as possible in a list of tokens.\n *\n * When given a tokenlist, this function returns a new list with ranges returned\n * as whole references (`Sheet1!A1:B2`) rather than separate tokens for each\n * part: (`Sheet1`,`!`,`A1`,`:`,`B2`).\n *\n * @param tokenlist An array of tokens.\n * @returns A new list of tokens with range parts merged.\n */\nexport function mergeRefTokens (tokenlist: Token[]): Token[] {\n  const finalTokens = [];\n  // this seeks backwards because it's really the range part\n  // that controls what can be joined.\n  for (let i = tokenlist.length - 1; i >= 0; i--) {\n    let token = tokenlist[i];\n    const type = token.type;\n    // Quick check if token type could even start a valid run\n    if (type === REF_RANGE || type === REF_BEAM || type === REF_TERNARY ||\n        type === REF_NAMED || type === REF_STRUCT) {\n      const valid = matcher(tokenlist, refPartsTree, i);\n      if (valid > 1) {\n        token = { ...token, value: '' };\n        const start = i - valid + 1;\n        for (let j = start; j <= i; j++) {\n          token.value += tokenlist[j].value;\n        }\n        // adjust the offsets to include all the text\n        if (token.loc && tokenlist[start].loc) {\n          token.loc[0] = tokenlist[start].loc[0];\n        }\n        i -= valid - 1;\n      }\n    }\n    finalTokens[finalTokens.length] = token;\n  }\n  return finalTokens.reverse();\n}\n","import { ERROR } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nconst re_ERROR = /#(?:NAME\\?|FIELD!|CALC!|VALUE!|REF!|DIV\\/0!|NULL!|NUM!|N\\/A|GETTING_DATA\\b|SPILL!|UNKNOWN!|SYNTAX\\?|ERROR!|CONNECT!|BLOCKED!|EXTERNAL!)/iy;\nconst HASH = 35;\n\nexport function lexError (str: string, pos: number): Token | undefined {\n  if (str.charCodeAt(pos) === HASH) {\n    re_ERROR.lastIndex = pos;\n    const m = re_ERROR.exec(str);\n    if (m) {\n      return { type: ERROR, value: m[0] };\n    }\n  }\n}\n","import { OPERATOR_TRIM } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nconst PERIOD = 46;\nconst COLON = 58;\n\nexport function lexRangeTrim (str: string, pos: number): Token | undefined {\n  const c0 = str.charCodeAt(pos);\n  if (c0 === PERIOD || c0 === COLON) {\n    const c1 = str.charCodeAt(pos + 1);\n    if (c0 !== c1) {\n      if (c1 === COLON) {\n        return {\n          type: OPERATOR_TRIM,\n          value: str.slice(pos, pos + (str.charCodeAt(pos + 2) === PERIOD ? 3 : 2))\n        };\n      }\n      else if (c1 === PERIOD) {\n        return {\n          type: OPERATOR_TRIM,\n          value: str.slice(pos, pos + 2)\n        };\n      }\n    }\n  }\n}\n","import { OPERATOR } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nexport function lexOperator (str: string, pos: number): Token | undefined {\n  const c0 = str.charCodeAt(pos);\n  const c1 = str.charCodeAt(pos + 1);\n  if (\n    (c0 === 60 && c1 === 61) || // <=\n    (c0 === 62 && c1 === 61) || // >=\n    (c0 === 60 && c1 === 62)    // <>\n  ) {\n    return { type: OPERATOR, value: str.slice(pos, pos + 2) };\n  }\n  if (\n    // { } ! # % &\n    c0 === 123 || c0 === 125 || c0 === 33 || c0 === 35 || c0 === 37 || c0 === 38 ||\n    // ( ) * + , -\n    (c0 >= 40 && c0 <= 45) ||\n    // / : ; < = >\n    c0 === 47 || (c0 >= 58 && c0 <= 62) ||\n    // @ ^\n    c0 === 64 || c0 === 94\n  ) {\n    return { type: OPERATOR, value: str[pos] };\n  }\n}\n","import { BOOLEAN } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nfunction preventMatch (c: number) {\n  return (\n    (c >= 65 && c <= 90) || // A-Z\n    (c >= 97 && c <= 122) || // a-z\n    (c >= 48 && c <= 57) || // 0-9\n    (c === 95) || // _\n    (c === 92) || // \\\n    (c === 40) || // (\n    (c === 46) || // .\n    (c === 63) || // ?\n    (c > 0xA0) // \\u00a1-\\uffff\n  );\n}\n\nexport function lexBoolean (str: string, pos: number): Token | undefined {\n  // \"true\" (case insensitive)\n  const c0 = str.charCodeAt(pos);\n  if (c0 === 84 || c0 === 116) {\n    const c1 = str.charCodeAt(pos + 1);\n    if (c1 === 82 || c1 === 114) {\n      const c2 = str.charCodeAt(pos + 2);\n      if (c2 === 85 || c2 === 117) {\n        const c3 = str.charCodeAt(pos + 3);\n        if (c3 === 69 || c3 === 101) {\n          const c4 = str.charCodeAt(pos + 4);\n          if (!preventMatch(c4)) {\n            return { type: BOOLEAN, value: str.slice(pos, pos + 4) };\n          }\n        }\n      }\n    }\n  }\n  // \"false\" (case insensitive)\n  if (c0 === 70 || c0 === 102) {\n    const c1 = str.charCodeAt(pos + 1);\n    if (c1 === 65 || c1 === 97) {\n      const c2 = str.charCodeAt(pos + 2);\n      if (c2 === 76 || c2 === 108) {\n        const c3 = str.charCodeAt(pos + 3);\n        if (c3 === 83 || c3 === 115) {\n          const c4 = str.charCodeAt(pos + 4);\n          if (c4 === 69 || c4 === 101) {\n            const c5 = str.charCodeAt(pos + 5);\n            if (!preventMatch(c5)) {\n              return { type: BOOLEAN, value: str.slice(pos, pos + 5) };\n            }\n          }\n        }\n      }\n    }\n  }\n}\n","import { NEWLINE } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nexport function lexNewLine (str: string, pos: number): Token | undefined {\n  const start = pos;\n  while (str.charCodeAt(pos) === 10) {\n    pos++;\n  }\n  if (pos !== start) {\n    return { type: NEWLINE, value: str.slice(start, pos) };\n  }\n}\n","import { WHITESPACE } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nexport function isWS (c) {\n  return (\n    c === 0x9 ||\n    c === 0xB ||\n    c === 0xC ||\n    c === 0xD ||\n    c === 0x20 ||\n    c === 0xA0 ||\n    c === 0x1680 ||\n    c === 0x2028 ||\n    c === 0x2029 ||\n    c === 0x202f ||\n    c === 0x205f ||\n    c === 0x3000 ||\n    c === 0xfeff ||\n    (c >= 0x2000 && c <= 0x200a)\n  );\n}\n\nexport function lexWhitespace (str: string, pos: number): Token | undefined {\n  const start = pos;\n  while (isWS(str.charCodeAt(pos))) {\n    pos++;\n  }\n  if (pos !== start) {\n    return { type: WHITESPACE, value: str.slice(start, pos) };\n  }\n}\n","import { STRING } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nconst QUOT = 34;\n\nexport function lexString (str: string, pos: number): Token | undefined {\n  const start = pos;\n  if (str.charCodeAt(pos) === QUOT) {\n    pos++;\n    while (pos < str.length) {\n      const c = str.charCodeAt(pos);\n      if (c === QUOT) {\n        pos++;\n        if (str.charCodeAt(pos) !== QUOT) {\n          return { type: STRING, value: str.slice(start, pos) };\n        }\n      }\n      pos++;\n    }\n    return { type: STRING, value: str.slice(start, pos), unterminated: true };\n  }\n}\n","import { CONTEXT, CONTEXT_QUOTE } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nconst QUOT_SINGLE = 39; // '\nconst BR_OPEN = 91; // [\nconst BR_CLOSE = 93; // ]\nconst EXCL = 33; // !\n\n// xlsx xml uses a variant of the syntax that has external references in\n// bracets. Any of: [1]Sheet1!A1, '[1]Sheet one'!A1, [1]!named\nexport function lexContextQuoted (str: string, pos: number, options: { xlsx: boolean }): Token | undefined {\n  const c0 = str.charCodeAt(pos);\n  let br1: number;\n  let br2: number;\n  // quoted context: '(?:''|[^'])*('|$)(?=!)\n  if (c0 === QUOT_SINGLE) {\n    const start = pos;\n    pos++;\n    while (pos < str.length) {\n      const c = str.charCodeAt(pos);\n      if (c === BR_OPEN) {\n        if (br1) { return; } // only 1 allowed\n        br1 = pos;\n      }\n      else if (c === BR_CLOSE) {\n        if (br2) { return; } // only 1 allowed\n        br2 = pos;\n      }\n      else if (c === QUOT_SINGLE) {\n        pos++;\n        if (str.charCodeAt(pos) !== QUOT_SINGLE) {\n          let valid = br1 == null && br2 == null;\n          if (options.xlsx && (br1 === start + 1) && (br2 === pos - 2)) {\n            valid = true;\n          }\n          if ((br1 >= start + 1) && (br2 < pos - 2) && (br2 > br1 + 1)) {\n            valid = true;\n          }\n          if (valid && str.charCodeAt(pos) === EXCL) {\n            return { type: CONTEXT_QUOTE, value: str.slice(start, pos) };\n          }\n          return;\n        }\n      }\n      pos++;\n    }\n  }\n}\n\n// xlsx xml uses a variant of the syntax that has external references in\n// bracets. Any of: [1]Sheet1!A1, '[1]Sheet one'!A1, [1]!named\nexport function lexContextUnquoted (str: string, pos: number, options: { xlsx: boolean }): Token | undefined {\n  const c0 = str.charCodeAt(pos);\n  let br1: number;\n  let br2: number;\n  if (c0 !== QUOT_SINGLE && c0 !== EXCL) {\n    const start = pos;\n    while (pos < str.length) {\n      const c = str.charCodeAt(pos);\n      if (c === BR_OPEN) {\n        if (br1) { return; } // only 1 allowed\n        br1 = pos;\n      }\n      else if (c === BR_CLOSE) {\n        if (br2) { return; } // only 1 allowed\n        br2 = pos;\n      }\n      else if (c === EXCL) {\n        let valid = br1 == null && br2 == null;\n        if (options.xlsx && (br1 === start) && (br2 === pos - 1)) {\n          valid = true;\n        }\n        if ((br1 >= start) && (br2 < pos - 1) && (br2 > br1 + 1)) {\n          valid = true;\n        }\n        if (valid) {\n          return { type: CONTEXT, value: str.slice(start, pos) };\n        }\n      }\n      else if (\n        (br1 == null || br2 != null) &&\n        // [0-9A-Za-z._¡¤§¨ª\\u00ad¯-\\uffff]\n        !(\n          (c >= 65 && c <= 90) || // A-Z\n          (c >= 97 && c <= 122) || // a-z\n          (c >= 48 && c <= 57) || // 0-9\n          (c === 46) || // .\n          (c === 95) || // _\n          (c === 161) || // ¡\n          (c === 164) || // ¤\n          (c === 167) || // §\n          (c === 168) || // ¨\n          (c === 170) || // ª\n          (c === 173) || // \\u00ad\n          (c >= 175)    // ¯-\\uffff\n        )\n      ) {\n        return;\n      }\n      // 0-9A-Za-z._¡¤§¨ª\\u00ad¯-\\uffff\n      pos++;\n    }\n  }\n}\n","const PERIOD = 46;\nconst COLON = 58;\n\nexport function advRangeOp (str: string, pos: number): number {\n  const c0 = str.charCodeAt(pos);\n  if (c0 === PERIOD) {\n    const c1 = str.charCodeAt(pos + 1);\n    if (c1 === COLON) {\n      return str.charCodeAt(pos + 2) === PERIOD ? 3 : 2;\n    }\n  }\n  else if (c0 === COLON) {\n    const c1 = str.charCodeAt(pos + 1);\n    return c1 === PERIOD ? 2 : 1;\n  }\n  return 0;\n}\n\n","// regular: [A-Za-z0-9_\\u00a1-\\uffff]\nexport function canEndRange (str: string, pos: number): boolean {\n  const c = str.charCodeAt(pos);\n  return !(\n    (c >= 65 && c <= 90) || // A-Z\n    (c >= 97 && c <= 122) || // a-z\n    (c >= 48 && c <= 57) || // 0-9\n    (c === 95) || // _\n    (c === 40) || // (\n    (c > 0xA0) // \\u00a1-\\uffff\n  );\n}\n\n// partial: [A-Za-z0-9_($.]\n// Also rejects \"!\" — a ternary range must not end where a sheet prefix\n// begins (e.g. \"F2:B\" in \"B!F2:B!F20\" is not a ternary range; the\n// trailing \"B\" is the start of the second sheet prefix \"B!\").\nexport function canEndPartialRange (str: string, pos: number): boolean {\n  const c = str.charCodeAt(pos);\n  return !(\n    (c >= 65 && c <= 90) || // A-Z\n    (c >= 97 && c <= 122) || // a-z\n    (c >= 48 && c <= 57) || // 0-9\n    (c === 95) || // _\n    (c === 40) || // (\n    (c === 36) || // $\n    (c === 46) || // .\n    (c === 33) // !\n  );\n}\n","import { REF_RANGE, REF_BEAM, REF_TERNARY, MAX_COLS, MAX_ROWS } from '../constants.ts';\nimport type { Token } from '../types.ts';\nimport { advRangeOp } from './advRangeOp.ts';\nimport { canEndRange, canEndPartialRange } from './canEndRange.ts';\n\nfunction advA1Col (str: string, pos: number): number {\n  // [A-Z]{1,3}\n  const start = pos;\n  if (str.charCodeAt(pos) === 36) { // $\n    pos++;\n  }\n  const stop = pos + 3;\n  let col = 0;\n  do {\n    const c = str.charCodeAt(pos);\n    if (c >= 65 && c <= 90) { // A-Z\n      col = 26 * col + c - 64;\n      pos++;\n    }\n    else if (c >= 97 && c <= 122) { // a-z\n      col = 26 * col + c - 96;\n      pos++;\n    }\n    else {\n      break;\n    }\n  }\n  while (pos < stop && pos < str.length);\n  return (col && col <= MAX_COLS + 1) ? pos - start : 0;\n}\n\nfunction advA1Row (str: string, pos: number): number {\n  // [1-9][0-9]{0,6}\n  const start = pos;\n  if (str.charCodeAt(pos) === 36) { // $\n    pos++;\n  }\n  const stop = pos + 7;\n  let row = 0;\n  let c = str.charCodeAt(pos);\n  if (c >= 49 && c <= 57) { // 1-9\n    row = row * 10 + c - 48;\n    pos++;\n    do {\n      c = str.charCodeAt(pos);\n      if (c >= 48 && c <= 57) { // 0-9\n        row = row * 10 + c - 48;\n        pos++;\n      }\n      else {\n        break;\n      }\n    }\n    while (pos < stop && pos < str.length);\n  }\n  return (row && row <= MAX_ROWS + 1) ? pos - start : 0;\n}\n\nexport function lexRangeA1 (\n  str: string,\n  pos: number,\n  options: { mergeRefs: boolean, allowTernary: boolean }\n): Token | undefined {\n  let p = pos;\n  const left = advA1Col(str, p);\n  let right = 0;\n  let bottom = 0;\n  if (left) {\n    // TLBR: could be A1:A1\n    // TL R: could be A1:A (if allowTernary)\n    // TLB : could be A1:1 (if allowTernary)\n    //  LBR: could be A:A1 (if allowTernary)\n    //  L R: could be A:A\n    p += left;\n    const top = advA1Row(str, p);\n    p += top;\n    const op = advRangeOp(str, p);\n    const preOp = p;\n    if (op) {\n      p += op;\n      right = advA1Col(str, p);\n      p += right;\n      bottom = advA1Row(str, p);\n      p += bottom;\n      if (top && bottom && right) {\n        if (canEndRange(str, p) && options.mergeRefs) {\n          return { type: REF_RANGE, value: str.slice(pos, p) };\n        }\n      }\n      else if (!top && !bottom) {\n        if (canEndRange(str, p)) {\n          return { type: REF_BEAM, value: str.slice(pos, p) };\n        }\n      }\n      else if (options.allowTernary && (bottom || right)) {\n        if (canEndPartialRange(str, p)) {\n          return { type: REF_TERNARY, value: str.slice(pos, p) };\n        }\n      }\n    }\n    // LT  : this is A1\n    if (top && canEndRange(str, preOp) && str.charCodeAt(preOp) !== 33) { // 33 = \"!\"\n      return { type: REF_RANGE, value: str.slice(pos, preOp) };\n    }\n  }\n  else {\n    // T B : could be 1:1\n    // T BR: could be 1:A1 (if allowTernary)\n    const top = advA1Row(str, p);\n    if (top) {\n      p += top;\n      const op = advRangeOp(str, p);\n      if (op) {\n        p += op;\n        right = advA1Col(str, p);\n        if (right) {\n          p += right;\n        }\n        bottom = advA1Row(str, p);\n        p += bottom;\n        if (right && bottom && options.allowTernary) {\n          if (canEndPartialRange(str, p)) {\n            return { type: REF_TERNARY, value: str.slice(pos, p) };\n          }\n        }\n        if (!right && bottom) {\n          if (canEndRange(str, p)) {\n            return { type: REF_BEAM, value: str.slice(pos, p) };\n          }\n        }\n      }\n    }\n  }\n}\n","import { REF_RANGE, REF_BEAM, REF_TERNARY, MAX_COLS, MAX_ROWS } from '../constants.ts';\nimport type { Token } from '../types.ts';\nimport { advRangeOp } from './advRangeOp.ts';\nimport { canEndRange } from './canEndRange.ts';\n\nconst BR_OPEN = 91; // [\nconst BR_CLOSE = 93; // ]\nconst UC_R = 82;\nconst LC_R = 114;\nconst UC_C = 67;\nconst LC_C = 99;\nconst PLUS = 43;\nconst MINUS = 45;\nconst EXCL = 33;\n\n// C\n// C\\[[+-]?\\d+\\]\n// C[1-9][0-9]{0,4}\n// R\n// R\\[[+-]?\\d+\\]\n// R[1-9][0-9]{0,6}\nfunction lexR1C1Part (str: string, pos: number, isRow: boolean = false): number {\n  const start = pos;\n  const c0 = str.charCodeAt(pos);\n  if ((isRow ? c0 === UC_R || c0 === LC_R : c0 === UC_C || c0 === LC_C)) {\n    pos++;\n    let digits = 0;\n    let value = 0;\n    let stop = str.length;\n    const c1 = str.charCodeAt(pos);\n    let c;\n    let sign = 1;\n    const relative = c1 === BR_OPEN;\n    if (relative) {\n      stop = Math.min(stop, pos + (isRow ? 8 : 6));\n      pos++;\n      // allow +-\n      c = str.charCodeAt(pos);\n      if (c === PLUS || c === MINUS) {\n        pos++;\n        stop++;\n        sign = c === MINUS ? -1 : 1;\n      }\n    }\n    else if (c1 < 49 || c1 > 57 || isNaN(c1)) {\n      // char must be 1-9, or part is either just \"R\" or \"C\"\n      return 1;\n    }\n\n    do {\n      const c = str.charCodeAt(pos);\n      if (c >= 48 && c <= 57) { // 0-9\n        value = value * 10 + c - 48;\n        digits++;\n        pos++;\n      }\n      else {\n        break;\n      }\n    }\n    while (pos < stop);\n\n    const MAX = isRow ? MAX_ROWS : MAX_COLS;\n    if (relative) {\n      const c = str.charCodeAt(pos);\n      if (c !== BR_CLOSE) {\n        return 0;\n      }\n      // isRow: next char must not be a number!\n      pos++;\n      value *= sign;\n      return (digits && (-MAX <= value) && (value <= MAX))\n        ? pos - start\n        : 0;\n    }\n    // isRow: next char must not be a number!\n    return (digits && value <= (MAX + 1)) ? pos - start : 0;\n  }\n  return 0;\n}\n\nexport function lexRangeR1C1 (\n  str: string,\n  pos: number,\n  options: { allowTernary: boolean }\n): Token | undefined {\n  let p = pos;\n  // C1\n  // C1:C1\n  // C1:R1C1  --partial\n  // R1\n  // R1:R1\n  // R1:R1C1  --partial\n  // R1C1\n  // R1C1:C1  --partial\n  // R1C1:R1  --partial\n  const r1 = lexR1C1Part(str, p, true);\n  p += r1;\n  const c1 = lexR1C1Part(str, p);\n  p += c1;\n  if ((c1 || r1) && str.charCodeAt(p) !== EXCL) {\n    const op = advRangeOp(str, p);\n    const preOp = p;\n    if (op) {\n      p += op;\n      const r2 = lexR1C1Part(str, p, true); // R1\n      p += r2;\n      const c2 = lexR1C1Part(str, p); // C1\n      p += c2;\n\n      // C1:R2C2  --partial\n      // R1:R2C2  --partial\n      // R1C1:C2  --partial\n      // R1C1:R2  --partial\n      if (\n        (r1 && !c1 && r2 && c2) ||\n        (!r1 && c1 && r2 && c2) ||\n        (r1 && c1 && r2 && !c2) ||\n        (r1 && c1 && !r2 && c2)\n      ) {\n        if (options.allowTernary && canEndRange(str, p)) {\n          return { type: REF_TERNARY, value: str.slice(pos, p) };\n        }\n      }\n      // C1:C2 -- beam\n      // R1:R2 -- beam\n      else if (\n        (c1 && c2 && !r1 && !r2) ||\n        (!c1 && !c2 && r1 && r2)\n      ) {\n        if (canEndRange(str, p)) {\n          return { type: REF_BEAM, value: str.slice(pos, p) };\n        }\n      }\n      // Note: we do not capture R1C1:R1C1, mergeRefTokens will join the parts\n    }\n    // R1\n    // C1\n    // R1C1\n    if (canEndRange(str, preOp)) {\n      return {\n        type: (r1 && c1) ? REF_RANGE : REF_BEAM,\n        value: str.slice(pos, preOp)\n      };\n    }\n  }\n}\n","import type { Token } from '../types.ts';\nimport { lexRangeA1 } from './lexRangeA1.ts';\nimport { lexRangeR1C1 } from './lexRangeR1C1.ts';\n\ntype LexRangeOptions = {\n  allowTernary: boolean,\n  mergeRefs: boolean,\n  r1c1: boolean\n};\n\nexport function lexRange (str: string, pos: number, options: LexRangeOptions): Token | undefined {\n  return options.r1c1\n    ? lexRangeR1C1(str, pos, options)\n    : lexRangeA1(str, pos, options);\n}\n","import { isWS } from './lexers/lexWhitespace.ts';\n\nconst AT = 64; // @\nconst BR_CLOSE = 93; // ]\nconst BR_OPEN = 91; // [\nconst COLON = 58; // :\nconst COMMA = 44; // ,\nconst HASH = 35; // #\nconst QUOT_SINGLE = 39; // '\n\nconst keyTerms = {\n  'headers': 1,\n  'data': 2,\n  'totals': 4,\n  'all': 8,\n  'this row': 16,\n  '@': 16\n};\n\n// only combinations allowed are: #data + (#headers | #totals | #data)\nconst fz = (...a: string[]) => Object.freeze(a);\nconst sectionMap = {\n  // no terms\n  0: fz(),\n  // single term\n  1: fz('headers'),\n  2: fz('data'),\n  4: fz('totals'),\n  8: fz('all'),\n  16: fz('this row'),\n  // headers+data\n  3: fz('headers', 'data'),\n  // totals+data\n  6: fz('data', 'totals')\n};\n\nfunction matchKeyword (str: string, pos: number): number {\n  let p = pos;\n  if (str.charCodeAt(p++) !== BR_OPEN) {\n    return;\n  }\n  if (str.charCodeAt(p++) !== HASH) {\n    return;\n  }\n  do {\n    const c = str.charCodeAt(p);\n    if (\n      (c >= 65 && c <= 90) || // A-Z\n      (c >= 97 && c <= 122) || // a-z\n      (c === 32) // space\n    ) {\n      p++;\n    }\n    else {\n      break;\n    }\n  }\n  while (p < pos + 11); // max length: '[#this row'\n  if (str.charCodeAt(p++) !== BR_CLOSE) {\n    return;\n  }\n  return p - pos;\n}\n\nfunction skipWhitespace (str: string, pos: number): number {\n  let p = pos;\n  while (isWS(str.charCodeAt(p))) { p++; }\n  return p - pos;\n}\n\nfunction matchColumn (str: string, pos: number, allowUnbraced = true): [ string, string ] {\n  let p = pos;\n  let column = '';\n  if (str.charCodeAt(p) === BR_OPEN) {\n    p++;\n    let c;\n    do {\n      c = str.charCodeAt(p);\n      if (c === QUOT_SINGLE) {\n        p++;\n        c = str.charCodeAt(p);\n        // Allowed set: '#@[]\n        if (c === QUOT_SINGLE || c === HASH || c === AT || c === BR_OPEN || c === BR_CLOSE) {\n          column += String.fromCharCode(c);\n          p++;\n        }\n        else {\n          return;\n        }\n      }\n      // Allowed set is all chars BUT: '#@[]\n      else if (c === QUOT_SINGLE || c === HASH || c === AT || c === BR_OPEN) {\n        return;\n      }\n      else if (c === BR_CLOSE) {\n        p++;\n        return [ str.slice(pos, p), column ];\n      }\n      else {\n        column += String.fromCharCode(c);\n        p++;\n      }\n    }\n    while (p < str.length);\n  }\n  else if (allowUnbraced) {\n    let c;\n    do {\n      c = str.charCodeAt(p);\n      // Allowed set is all chars BUT: '#@[]:\n      if (c === QUOT_SINGLE || c === HASH || c === AT || c === BR_OPEN || c === BR_CLOSE || c === COLON) {\n        break;\n      }\n      else {\n        column += String.fromCharCode(c);\n        p++;\n      }\n    }\n    while (p < str.length);\n    if (p !== pos) {\n      return [ column, column ];\n    }\n  }\n}\n\nexport type SRange = {\n  columns: string[],\n  sections: string[],\n  length: number,\n  token: string\n};\n\nexport function parseSRange (str: string, pos: number = 0): SRange {\n  const columns: string[] = [];\n  const start = pos;\n  let m;\n  let terms = 0;\n\n  // structured refs start with a [\n  if (str.charCodeAt(pos) !== BR_OPEN) {\n    return;\n  }\n\n  // simple keyword: [#keyword]\n  if ((m = matchKeyword(str, pos))) {\n    const k = str.slice(pos + 2, pos + m - 1);\n    pos += m;\n    const term = keyTerms[k.toLowerCase()];\n    if (!term) { return; }\n    terms |= term;\n  }\n  // simple column: [column]\n  else if ((m = matchColumn(str, pos, false))) {\n    pos += m[0].length;\n    if (m[1]) {\n      columns.push(m[1]);\n    }\n  }\n  // use the \"normal\" method\n  // [[#keyword]]\n  // [[column]]\n  // [@]\n  // [@column]\n  // [@[column]]\n  // [@column:column]\n  // [@column:[column]]\n  // [@[column]:column]\n  // [@[column]:[column]]\n  // [column:column]\n  // [column:[column]]\n  // [[column]:column]\n  // [[column]:[column]]\n  // [[#keyword],column]\n  // [[#keyword],column:column]\n  // [[#keyword],[#keyword],column:column]\n  // ...\n  else {\n    let expect_more = true;\n    pos++; // skip open brace\n    pos += skipWhitespace(str, pos);\n    // match keywords as we find them\n    while (expect_more && (m = matchKeyword(str, pos))) {\n      const k = str.slice(pos + 2, pos + m - 1);\n      const term = keyTerms[k.toLowerCase()];\n      if (!term) { return; }\n      terms |= term;\n      pos += m;\n      pos += skipWhitespace(str, pos);\n      expect_more = str.charCodeAt(pos) === COMMA;\n      if (expect_more) {\n        pos++;\n        pos += skipWhitespace(str, pos);\n      }\n    }\n    // is there an @ specifier?\n    if (expect_more && (str.charCodeAt(pos) === AT)) {\n      terms |= keyTerms['@'];\n      pos += 1;\n      expect_more = str.charCodeAt(pos) !== BR_CLOSE;\n    }\n    // not all keyword terms may be combined\n    if (!sectionMap[terms]) {\n      return;\n    }\n    // column definitions\n    const leftCol = expect_more && matchColumn(str, pos, true);\n    if (leftCol) {\n      pos += leftCol[0].length;\n      columns.push(leftCol[1]);\n      if (str.charCodeAt(pos) === COLON) {\n        pos++;\n        const rightCol = matchColumn(str, pos, true);\n        if (rightCol) {\n          pos += rightCol[0].length;\n          columns.push(rightCol[1]);\n        }\n        else {\n          return;\n        }\n      }\n      expect_more = false;\n    }\n    // advance ws\n    pos += skipWhitespace(str, pos);\n    // close the ref\n    if (expect_more || str.charCodeAt(pos) !== BR_CLOSE) {\n      return;\n    }\n    // step over the closing ]\n    pos++;\n  }\n\n  const sections: string[] = sectionMap[terms];\n  return {\n    columns,\n    sections: sections ? sections.concat() : sections,\n    length: pos - start,\n    token: str.slice(start, pos)\n  };\n}\n","import { parseSRange } from '../parseSRange.ts';\nimport { REF_STRUCT } from '../constants.ts';\nimport { isWS } from './lexWhitespace.ts';\nimport type { Token } from '../types.ts';\n\nconst EXCL = 33; // !\n\nexport function lexStructured (str: string, pos: number): Token | undefined {\n  const structData = parseSRange(str, pos);\n  if (structData && structData.length) {\n    // we have a match for a valid SR\n    let i = structData.length;\n    // skip tailing whitespace\n    while (isWS(str.charCodeAt(pos + i))) {\n      i++;\n    }\n    // and ensure that it isn't followed by a !\n    if (str.charCodeAt(pos + i) !== EXCL) {\n      return {\n        type: REF_STRUCT,\n        value: structData.token\n      };\n    }\n  }\n}\n","import { NUMBER } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\nfunction advDigits (str: string, pos: number): number {\n  const start = pos;\n  do {\n    const c = str.charCodeAt(pos);\n    if (c < 48 || c > 57) { // 0-9\n      break;\n    }\n    pos++;\n  }\n  while (pos < str.length);\n  return pos - start;\n}\n\n// \\d+(\\.\\d+)?(?:[eE][+-]?\\d+)?\nexport function lexNumber (str: string, pos: number): Token | undefined {\n  const start = pos;\n\n  // integer\n  const lead = advDigits(str, pos);\n  if (!lead) { return; }\n  pos += lead;\n\n  // optional fraction part\n  const c0 = str.charCodeAt(pos);\n  if (c0 === 46) { // .\n    pos++;\n    const frac = advDigits(str, pos);\n    if (!frac) { return; }\n    pos += frac;\n  }\n  // optional exponent part\n  const c1 = str.charCodeAt(pos);\n  if (c1 === 69 || c1 === 101) { // E e\n    pos++;\n    const sign = str.charCodeAt(pos);\n    if (sign === 43 || sign === 45) { // + -\n      pos++;\n    }\n    const exp = advDigits(str, pos);\n    if (!exp) { return; }\n    pos += exp;\n  }\n\n  return { type: NUMBER, value: str.slice(start, pos) };\n}\n","import { REF_NAMED } from '../constants.ts';\nimport type { Token } from '../types.ts';\n\n// The advertized named ranges rules are a bit off from what Excel seems to do.\n// In the \"extended range\" of chars, it looks like it allows most things above\n// U+00B0 with the range between U+00A0-U+00AF rather random:\n// /^[a-zA-Z\\\\_¡¤§¨ª\\u00ad¯\\u00b0-\\uffff][a-zA-Z0-9\\\\_.?¡¤§¨ª\\u00ad¯\\u00b0-\\uffff]{0,254}/\n//\n// I've simplified to allowing everything above U+00A1:\n// /^[a-zA-Z\\\\_\\u00a1-\\uffff][a-zA-Z0-9\\\\_.?\\u00a1-\\uffff]{0,254}/\nexport function lexNamed (str: string, pos: number): Token | undefined {\n  const start = pos;\n  // starts with: [a-zA-Z\\\\_\\u00a1-\\uffff]\n  const s = str.charCodeAt(pos);\n  if (\n    (s >= 65 && s <= 90) || // A-Z\n    (s >= 97 && s <= 122) || // a-z\n    (s === 95) || // _\n    (s === 92) || // \\\n    (s > 0xA0) // \\u00a1-\\uffff\n  ) {\n    pos++;\n  }\n  else {\n    return;\n  }\n  // has any number of: [a-zA-Z0-9\\\\_.?\\u00a1-\\uffff]\n  let c: number;\n  do {\n    c = str.charCodeAt(pos);\n    if (\n      (c >= 65 && c <= 90) || // A-Z\n      (c >= 97 && c <= 122) || // a-z\n      (c >= 48 && c <= 57) || // 0-9\n      (c === 95) || // _\n      (c === 92) || // \\\n      (c === 46) || // .\n      (c === 63) || // ?\n      (c > 0xA0) // \\u00a1-\\uffff\n    ) {\n      pos++;\n    }\n    else {\n      break;\n    }\n  } while (isFinite(c));\n\n  const len = pos - start;\n  if (len && len < 255) {\n    // names starting with \\ must be at least 3 char long\n    if (s === 92 && len < 3) {\n      return;\n    }\n    // single characters R and C are forbidden as names\n    if (len === 1 && (s === 114 || s === 82 || s === 99 || s === 67)) {\n      return;\n    }\n    return { type: REF_NAMED, value: str.slice(start, pos) };\n  }\n}\n","import { OPERATOR } from '../constants.ts';\nimport type { Token } from '../types.ts';\nimport { advRangeOp } from './advRangeOp.ts';\n\nconst EXCL = 33; // !\n\nexport function lexRefOp (str: string, pos: number, opts: { r1c1: boolean }): Token | undefined {\n  // in R1C1 mode we only allow [ '!' ]\n  if (str.charCodeAt(pos) === EXCL) {\n    return { type: OPERATOR, value: str[pos] };\n  }\n  if (!opts.r1c1) {\n    // in A1 mode we allow [ '!' ] + [ ':', '.:', ':.', '.:.']\n    const opLen = advRangeOp(str, pos);\n    if (opLen) {\n      return { type: OPERATOR, value: str.slice(pos, pos + opLen) };\n    }\n  }\n}\n","import { CONTEXT, FUNCTION, REF_NAMED, UNKNOWN } from '../constants.ts';\nimport type { Token } from '../types.ts';\nimport { lexContextUnquoted } from './lexContext.ts';\n\nconst BR_OPEN = 91; // [\nconst PAREN_OPEN = 40;\nconst EXCL = 33; // !\nconst OFFS = 32;\n\n// build a map of characters to allow-bitmasks\nconst ALLOWED = new Uint8Array(180 - OFFS);\nconst OK_NAME_0 = 0b000001;\nconst OK_FUNC_0 = 0b000010;\nconst OK_CNTX_0 = 0b000100;\nconst OK_NAME_N = 0b001000;\nconst OK_FUNC_N = 0b010000;\nconst OK_CNTX_N = 0b100000;\nconst OK_0 = OK_NAME_0 | OK_FUNC_0 | OK_CNTX_0;\nconst OK_N = OK_NAME_N | OK_FUNC_N | OK_CNTX_N;\nconst OK_HIGHCHAR = OK_NAME_0 | OK_NAME_N | OK_CNTX_0 | OK_CNTX_N;\nfor (let c = OFFS; c < 180; c++) {\n  const char = String.fromCharCode(c);\n  const n0 = /^[a-zA-Z_\\\\\\u00a1-\\uffff]$/.test(char);\n  const f0 = /^[a-zA-Z_]$/.test(char);\n  const nN = /^[a-zA-Z0-9_.\\\\?\\u00a1-\\uffff]$/.test(char);\n  const fN = /^[a-zA-Z0-9_.]$/.test(char);\n  const cX = /^[a-zA-Z0-9_.¡¤§¨ª\\u00ad¯-\\uffff]$/.test(char);\n  ALLOWED[c - OFFS] = (\n    (n0 ? OK_NAME_0 : 0) |\n    (nN ? OK_NAME_N : 0) |\n    (f0 ? OK_FUNC_0 : 0) |\n    (fN ? OK_FUNC_N : 0) |\n    (cX ? OK_CNTX_0 : 0) |\n    (cX ? OK_CNTX_N : 0)\n  );\n}\n\nfunction nameOrUnknown (str, s, start, pos, name) {\n  const len = pos - start;\n  if (name && len && len < 255) {\n    // names starting with \\ must be at least 3 char long\n    if (s === 92 && len < 3) {\n      return;\n    }\n    // single characters R and C are forbidden as names\n    if (len === 1 && (s === 114 || s === 82 || s === 99 || s === 67)) {\n      return;\n    }\n    return { type: REF_NAMED, value: str.slice(start, pos) };\n  }\n  return { type: UNKNOWN, value: str.slice(start, pos) };\n}\n\nexport function lexNameFuncCntx (\n  str: string,\n  pos: number,\n  opts: { xlsx: boolean }\n): Token | undefined {\n  const start = pos;\n\n  const s = str.charCodeAt(pos);\n  const a = s > 180 ? OK_HIGHCHAR : ALLOWED[s - OFFS];\n  // name: [a-zA-Z_\\\\\\u00a1-\\uffff]\n  // func: [a-zA-Z_]\n  // cntx: [a-zA-Z_0-9.¡¤§¨ª\\u00ad¯-\\uffff]\n  if (((a & OK_CNTX_0) && !(a & OK_NAME_0) && !(a & OK_FUNC_0)) || s === BR_OPEN) {\n    // its a context so delegate to that lexer\n    return lexContextUnquoted(str, pos, opts);\n  }\n  if (!(a & OK_0)) {\n    return;\n  }\n  let name = (a & OK_NAME_0) ? 1 : 0;\n  let func = (a & OK_FUNC_0) ? 1 : 0;\n  let cntx = (a & OK_CNTX_0) ? 1 : 0;\n  pos++;\n\n  let c: number;\n  do {\n    c = str.charCodeAt(pos);\n    const a = s > 180 ? OK_HIGHCHAR : ALLOWED[c - OFFS] ?? 0;\n    if (a & OK_N) {\n      // name: [a-zA-Z_0-9.\\\\?\\u00a1-\\uffff]\n      // func: [a-zA-Z_0-9.]\n      // cntx: [a-zA-Z_0-9.¡¤§¨ª\\u00ad¯-\\uffff]\n      if (name && !(a & OK_NAME_N)) {\n        name = 0;\n      }\n      if (func && !(a & OK_FUNC_N)) {\n        func = 0;\n      }\n      if (cntx && !(a & OK_CNTX_N)) {\n        cntx = 0;\n      }\n    }\n    else {\n      if (c === PAREN_OPEN && func) {\n        return { type: FUNCTION, value: str.slice(start, pos) };\n      }\n      else if (c === EXCL && cntx) {\n        return { type: CONTEXT, value: str.slice(start, pos) };\n      }\n      return nameOrUnknown(str, s, start, pos, name);\n    }\n    pos++;\n  }\n  while ((name || func || cntx) && pos < str.length);\n\n  if (start !== pos) {\n    return nameOrUnknown(str, s, start, pos, name);\n  }\n}\n","import { lexError } from './lexError.ts';\nimport { lexRangeTrim } from './lexRangeTrim.ts';\nimport { lexOperator } from './lexOperator.ts';\nimport { lexBoolean } from './lexBoolean.ts';\nimport { lexNewLine } from './lexNewLine.ts';\nimport { lexWhitespace } from './lexWhitespace.ts';\nimport { lexString } from './lexString.ts';\nimport { lexContextQuoted, lexContextUnquoted } from './lexContext.ts';\nimport { lexRange } from './lexRange.ts';\nimport { lexStructured } from './lexStructured.ts';\nimport { lexNumber } from './lexNumber.ts';\nimport { lexNamed } from './lexNamed.ts';\nimport { lexRefOp } from './lexRefOp.ts';\nimport { lexNameFuncCntx } from './lexNameFuncCntx.ts';\nimport type { Token } from '../types.ts';\n\nexport type PartLexer = (\n  str: string,\n  pos: number,\n  options?: Partial<{\n    xlsx: boolean,\n    allowTerniary: boolean,\n    allowTernary: boolean,\n    mergeRefs: boolean,\n    r1c1: boolean\n  }>\n) => Token | undefined;\n\nexport const lexers: PartLexer[] = [\n  lexError,\n  lexRangeTrim,\n  lexOperator,\n  lexNewLine,\n  lexWhitespace,\n  lexString,\n  lexRange,\n  lexNumber,\n  lexBoolean,\n  lexContextQuoted,\n  lexNameFuncCntx,\n  lexStructured\n];\n\nexport const lexersRefs = [\n  lexRefOp,\n  lexContextQuoted,\n  lexContextUnquoted,\n  lexRange,\n  lexStructured,\n  lexNamed\n];\n","export function isRCTokenValue (value: string): boolean {\n  return value === 'r' || value === 'R' || value === 'c' || value === 'C';\n}\n","import {\n  FX_PREFIX,\n  NEWLINE,\n  NUMBER,\n  OPERATOR,\n  REF_NAMED,\n  UNKNOWN,\n  WHITESPACE,\n  FUNCTION,\n  OPERATOR_TRIM,\n  REF_RANGE,\n  REF_BEAM\n} from './constants.ts';\nimport { mergeRefTokens } from './mergeRefTokens.ts';\nimport { lexers, type PartLexer } from './lexers/sets.ts';\nimport type { Token } from './types.ts';\nimport { isRCTokenValue } from './isRCTokenValue.ts';\n\nconst reLetLambda = /^l(?:ambda|et)$/i;\nconst isType = (t: Token, type: string) => t && t.type === type;\nconst isTextTokenType = (tokenType: string) => tokenType === REF_NAMED || tokenType === FUNCTION;\n\nconst causesBinaryMinus = (token: Token) => {\n  return !isType(token, OPERATOR) || (\n    token.value === '%' ||\n    token.value === '}' ||\n    token.value === ')' ||\n    token.value === '#'\n  );\n};\n\nfunction fixRCNames (tokens: Token[], r1c1Mode?: boolean): Token[] {\n  let withinCall = 0;\n  let parenDepth = 0;\n  let lastToken: Token;\n  for (const token of tokens) {\n    const tokenType = token.type;\n    if (tokenType === OPERATOR) {\n      if (token.value === '(') {\n        parenDepth++;\n        if (lastToken.type === FUNCTION) {\n          if (reLetLambda.test(lastToken.value)) {\n            withinCall = parenDepth;\n          }\n        }\n      }\n      else if (token.value === ')') {\n        parenDepth--;\n        if (parenDepth < withinCall) {\n          withinCall = 0;\n        }\n      }\n    }\n    else if (withinCall && tokenType === UNKNOWN && isRCTokenValue(token.value)) {\n      token.type = REF_NAMED;\n    }\n    else if (withinCall && r1c1Mode && tokenType === REF_BEAM && isRCTokenValue(token.value)) {\n      token.type = REF_NAMED;\n    }\n    lastToken = token;\n  }\n  return tokens;\n}\n\ntype OptsGetTokens = {\n  withLocation?: boolean,\n  mergeRefs?: boolean,\n  negativeNumbers?: boolean\n  allowTernary?: boolean\n  r1c1?: boolean\n  xlsx?: boolean\n};\n\nexport function getTokens (fx: string, tokenHandlers: PartLexer[], options: OptsGetTokens = {}) {\n  const {\n    withLocation = false,\n    mergeRefs = true,\n    negativeNumbers = true\n  } = options;\n  const opts = {\n    withLocation: withLocation,\n    mergeRefs: mergeRefs,\n    allowTernary: options.allowTernary ?? false,\n    negativeNumbers: negativeNumbers,\n    r1c1: options.r1c1 ?? false,\n    xlsx: options.xlsx ?? false\n  };\n\n  const tokens = [];\n  let pos = 0;\n  let letOrLambda = 0;\n  let unknownRC = 0;\n  const trimOps = [];\n\n  let tail0: Token; // last non-whitespace token\n  let tail1: Token; // penultimate non-whitespace token\n  let lastToken: Token; // last token\n  const pushToken = (token: Token) => {\n    let tokenType = token.type;\n    const isCurrUnknown = tokenType === UNKNOWN;\n    const isLastUnknown = lastToken && lastToken.type === UNKNOWN;\n    if (lastToken && (\n      (isCurrUnknown && isLastUnknown) ||\n      (isCurrUnknown && isTextTokenType(lastToken.type)) ||\n      (isLastUnknown && isTextTokenType(tokenType))\n    )) {\n      // UNKNOWN tokens \"contaminate\" sibling text tokens\n      lastToken.value += token.value;\n      lastToken.type = UNKNOWN;\n      if (withLocation) {\n        lastToken.loc[1] = token.loc[1];\n      }\n    }\n    else {\n      if (tokenType === OPERATOR_TRIM) {\n        trimOps.push(tokens.length);\n        tokenType = UNKNOWN;\n        token.type = UNKNOWN;\n      }\n      // push token as normally\n      tokens[tokens.length] = token;\n      lastToken = token;\n      if (tokenType !== WHITESPACE && tokenType !== NEWLINE) {\n        tail1 = tail0;\n        tail0 = token;\n      }\n    }\n  };\n\n  if (fx.startsWith('=')) {\n    const token: Token = { type: FX_PREFIX, value: '=' };\n    if (withLocation) {\n      token.loc = [ 0, 1 ];\n    }\n    pos++;\n    pushToken(token);\n  }\n\n  const numHandlers = tokenHandlers.length;\n  while (pos < fx.length) {\n    const startPos = pos;\n    let token;\n    for (let i = 0; i < numHandlers; i++) {\n      token = tokenHandlers[i](fx, pos, opts);\n      if (token) {\n        pos += token.value.length;\n        break;\n      }\n    }\n\n    if (!token) {\n      token = {\n        type: UNKNOWN,\n        value: fx[pos]\n      };\n      pos++;\n    }\n    if (withLocation) {\n      token.loc = [ startPos, pos ];\n    }\n\n    // make a note if we found a let/lambda call\n    if (lastToken && token.value === '(' && lastToken.type === FUNCTION) {\n      if (reLetLambda.test(lastToken.value)) {\n        letOrLambda++;\n      }\n    }\n    // Make a note if we found a R or C unknown or REF_BEAM token in R1C1 mode.\n    // It seemse unlikely that anyone does `F2 = LET(c,1,c+F:F)` as this is a\n    // circular reference (and not a very useful one), so we're assuming that\n    // all \"c\" or \"r\" tokens found within the LET are names.\n    if (token.value.length === 1 && (token.type === UNKNOWN || (opts.r1c1 && token.type === REF_BEAM))) {\n      unknownRC += isRCTokenValue(token.value) ? 1 : 0;\n    }\n\n    if (negativeNumbers && token.type === NUMBER) {\n      const last1 = lastToken;\n      // do we have a number preceded by a minus?\n      if (last1?.type === OPERATOR && last1.value === '-') {\n        // missing tail1 means we are at the start of the stream\n        if (\n          !tail1 ||\n          tail1.type === FX_PREFIX ||\n          !causesBinaryMinus(tail1)\n        ) {\n          const minus = tokens.pop();\n          token.value = '-' + token.value;\n          if (token.loc) {\n            // ensure offsets are up to date\n            token.loc[0] = minus.loc[0];\n          }\n          // next step tries to counter the screwing around with the tailing\n          // it should be correct again once we pushToken()\n          tail0 = tail1;\n          lastToken = tokens[tokens.length - 1];\n        }\n      }\n    }\n\n    pushToken(token);\n  }\n\n  // if we encountered both a LAMBDA/LET call, and unknown 'r' or 'c' tokens\n  // we'll turn the unknown tokens into names within the call.\n  if (unknownRC && letOrLambda) {\n    fixRCNames(tokens, opts.r1c1);\n  }\n\n  // Any OPERATOR_TRIM tokens have been indexed already, they now need to be\n  // either turned into OPERATORs or UNKNOWNs. Trim operators are only allowed\n  // between two REF_RANGE tokens as they are not valid in expressions as full\n  // operators.\n  for (const index of trimOps) {\n    const before = tokens[index - 1];\n    const after = tokens[index + 1];\n    tokens[index].type = (before?.type === REF_RANGE && after?.type === REF_RANGE)\n      ? OPERATOR\n      : UNKNOWN;\n  }\n\n  if (mergeRefs) {\n    return mergeRefTokens(tokens);\n  }\n\n  return tokens;\n}\n\n/**\n * Options for {@link tokenize}.\n */\nexport type OptsTokenize = {\n  /**\n   * Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`\n   * @defaultValue true\n   */\n  withLocation?: boolean,\n  /**\n   * Should ranges be returned as whole references (`Sheet1!A1:B2`) or as separate tokens for each\n   * part: (`Sheet1`,`!`,`A1`,`:`,`B2`). This is the same as calling [`mergeRefTokens`](#mergeRefTokens)\n   * @defaultValue true\n   */\n  mergeRefs?: boolean,\n  /**\n   * Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1`\n   * (alternatively these will be unary operations in the tree).\n   * @defaultValue true\n   */\n  negativeNumbers?: boolean\n  /**\n   * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`. These are supported\n   * by Google Sheets but not Excel. See: [References.md](./References.md).\n   * @defaultValue false\n   */\n  allowTernary?: boolean\n  /**\n   * Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.\n   * @defaultValue false\n   */\n  r1c1?: boolean\n};\n\n/**\n * Breaks a string formula into a list of tokens.\n *\n * The returned output will be an array of objects representing the tokens:\n *\n * ```js\n * [\n *   { type: FX_PREFIX, value: '=' },\n *   { type: FUNCTION, value: 'SUM' },\n *   { type: OPERATOR, value: '(' },\n *   { type: REF_RANGE, value: 'A1:B2' },\n *   { type: OPERATOR, value: ')' }\n * ]\n * ```\n *\n * A collection of token types may be found as an object as the {@link tokenTypes}\n * export on the package.\n *\n * _Warning:_ To support syntax highlighting as you type, `STRING` tokens are allowed to be\n * \"unterminated\". For example, the incomplete formula `=\"Hello world` would be\n * tokenized as:\n *\n * ```js\n * [\n *   { type: FX_PREFIX, value: '=' },\n *   { type: STRING, value: '\"Hello world', unterminated: true },\n * ]\n * ```\n *\n * Parsers will need to handle this.\n *\n * @see {@link OptsTokenize}\n * @see {@link tokenTypes}\n * @param formula An Excel formula string (an Excel expression).\n * @param [options]  Options\n * @returns An array of Tokens\n */\nexport function tokenize (\n  formula: string,\n  options: OptsTokenize = {}\n): Token[] {\n  return getTokens(formula, lexers, options);\n}\n\n/**\n * Breaks a string formula into a list of tokens.\n *\n * The returned output will be an array of objects representing the tokens:\n *\n * ```js\n * [\n *   { type: FX_PREFIX, value: '=' },\n *   { type: FUNCTION, value: 'SUM' },\n *   { type: OPERATOR, value: '(' },\n *   { type: REF_RANGE, value: 'A1:B2' },\n *   { type: OPERATOR, value: ')' }\n * ]\n * ```\n *\n * A collection of token types may be found as an object as the {@link tokenTypes}\n * export on the package.\n *\n * _Warning:_ To support syntax highlighting as you type, `STRING` tokens are allowed to be\n * \"unterminated\". For example, the incomplete formula `=\"Hello world` would be\n * tokenized as:\n *\n * ```js\n * [\n *   { type: FX_PREFIX, value: '=' },\n *   { type: STRING, value: '\"Hello world', unterminated: true },\n * ]\n * ```\n *\n * @see {@link OptsTokenize}\n * @see {@link tokenTypes}\n * @param formula An Excel formula string (an Excel expression).\n * @param [options]  Options\n * @returns An array of Tokens\n */\nexport function tokenizeXlsx (\n  formula: string,\n  options: OptsTokenize = {}\n): Token[] {\n  const opts = {\n    withLocation: options.withLocation ?? false,\n    mergeRefs: options.mergeRefs ?? true,\n    allowTernary: options.allowTernary ?? false,\n    negativeNumbers: options.negativeNumbers ?? true,\n    r1c1: options.r1c1 ?? false,\n    xlsx: true\n  };\n  return getTokens(formula, lexers, opts);\n}\n","import {\n  REF_RANGE, REF_BEAM, REF_NAMED, REF_TERNARY, REF_STRUCT,\n  FX_PREFIX, WHITESPACE, NEWLINE,\n  FUNCTION, OPERATOR,\n  ERROR, STRING, NUMBER, BOOLEAN\n} from './constants.ts';\nimport type { Token } from './types.ts';\n\n/**\n * Determines whether the specified token is a range.\n *\n * Returns `true` if the input is a token that has a type of either REF_RANGE\n * (`A1` or `A1:B2`), REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), or\n * REF_BEAM (`A:A` or `1:1`). In all other cases `false` is returned.\n *\n * @param token A token\n * @returns True if the specified token is range, False otherwise.\n */\nexport function isRange (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && (\n    token.type === REF_RANGE ||\n    token.type === REF_BEAM ||\n    token.type === REF_TERNARY\n  );\n}\n\n/**\n * Determines whether the specified token is a reference.\n *\n * Returns `true` if the input is a token of type REF_RANGE (`A1` or `A1:B2`),\n * REF_TERNARY (`A1:A`, `A1:1`, `1:A1`, or `A:A1`), REF_BEAM (`A:A` or `1:1`),\n * or REF_NAMED (`myrange`). In all other cases `false` is returned.\n *\n * @param token The token\n * @returns True if the specified token is reference, False otherwise.\n */\nexport function isReference (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && (\n    token.type === REF_RANGE ||\n    token.type === REF_BEAM ||\n    token.type === REF_TERNARY ||\n    token.type === REF_STRUCT ||\n    token.type === REF_NAMED\n  );\n}\n\n/**\n * Determines whether the specified token is a literal.\n *\n * Returns `true` if the input is a token of type BOOLEAN (`TRUE` or `FALSE`),\n * ERROR (`#VALUE!`), NUMBER (123.4), or STRING (`\"lorem ipsum\"`). In all other\n * cases `false` is returned.\n *\n * @param token The token\n * @returns True if the specified token is literal, False otherwise.\n */\nexport function isLiteral (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && (\n    token.type === BOOLEAN ||\n    token.type === ERROR ||\n    token.type === NUMBER ||\n    token.type === STRING\n  );\n}\n\n/**\n * Determines whether the specified token is an error.\n *\n * Returns `true` if the input is a token of type ERROR (`#VALUE!`). In all\n * other cases `false` is returned.\n *\n * @param token The token\n * @returns True if the specified token is error, False otherwise.\n */\nexport function isError (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && token.type === ERROR;\n}\n\n/**\n * Determines whether the specified token is whitespace.\n *\n * Returns `true` if the input is a token of type WHITESPACE (` `) or\n * NEWLINE (`\\n`). In all other cases `false` is returned.\n *\n * @param token The token\n * @returns True if the specified token is whitespace, False otherwise.\n */\nexport function isWhitespace (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && (\n    token.type === WHITESPACE ||\n    token.type === NEWLINE\n  );\n}\n\n/**\n * Determines whether the specified token is a function.\n *\n * Returns `true` if the input is a token of type FUNCTION.\n * In all other cases `false` is returned.\n *\n * @param token The token\n * @returns True if the specified token is function, False otherwise.\n */\nexport function isFunction (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && token.type === FUNCTION;\n}\n\n/**\n * Returns `true` if the input is a token of type FX_PREFIX (leading `=` in\n * formula). In all other cases `false` is returned.\n *\n * @param token The token\n * @returns True if the specified token is effects prefix, False otherwise.\n */\nexport function isFxPrefix (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && token.type === FX_PREFIX;\n}\n\n/**\n * Determines whether the specified token is an operator.\n *\n * Returns `true` if the input is a token of type OPERATOR (`+` or `:`). In all\n * other cases `false` is returned.\n *\n * @param token The token\n * @returns True if the specified token is operator, False otherwise.\n */\nexport function isOperator (token?: Pick<Token, 'type'> | null): boolean {\n  return !!token && token.type === OPERATOR;\n}\n","/*\n * Excel formula language parser\n *\n * This parser is a Top-Down Operator Precedence (Pratt) parser. It's based on\n * the one that Douglas Crockford describes in Chapter 9 of the O'Reilly book\n * Beutiful Code (http://crockford.com/javascript/tdop/tdop.html).\n *\n * The parser handles most basic things Excel/Sheets do except:\n * `Sheet1:Sheet2!A1` references cross contexts (3D references)\n */\nimport {\n  isReference,\n  isLiteral,\n  isFunction,\n  isWhitespace,\n  isFxPrefix,\n  isOperator,\n  isError\n} from './isType.ts';\nimport {\n  UNARY,\n  BINARY,\n  REFERENCE,\n  LITERAL,\n  ERROR_LITERAL,\n  CALL,\n  LAMBDA,\n  ARRAY,\n  IDENTIFIER,\n  NUMBER,\n  BOOLEAN,\n  ERROR,\n  STRING,\n  LET,\n  LET_DECL,\n  REF_NAMED,\n  REF_STRUCT,\n  REF_BEAM\n} from './constants.ts';\n\nimport type { Token } from './types.ts';\nimport type { ArrayExpression, AstExpression, BinaryExpression, CallExpression, Identifier, LambdaExpression, LetDeclarator, LetExpression, UnaryExpression } from './astTypes.ts';\n\nconst END = '(END)';\nconst FUNCTION = '(FUNCTION)';\nconst WHITESPACE = '(WHITESPACE)';\n\nconst refFunctions = [\n  'ANCHORARRAY',\n  'CHOOSE',\n  'DROP',\n  'IF',\n  'IFS',\n  'INDEX',\n  'INDIRECT',\n  'LAMBDA',\n  'LET',\n  'OFFSET',\n  'REDUCE',\n  'SINGLE',\n  'SWITCH',\n  'TAKE',\n  'TRIMRANGE',\n  'XLOOKUP'\n];\n\nconst symbolTable = {};\nlet currentNode;\nlet tokens: Token[];\nlet tokenIndex: number;\nlet permitArrayRanges = false;\nlet permitArrayCalls = false;\nlet looseRefCalls = false;\n\nconst isReferenceFunctionName = (fnName: string) => {\n  return looseRefCalls || refFunctions.includes(fnName.toUpperCase());\n};\n\nconst isReferenceToken = (token: Token, allowOperators = false) => {\n  const value = (token && token.value) + '';\n  if (isReference(token)) {\n    return true;\n  }\n  if (allowOperators && isOperator(token) && (value === ':' || value === ',' || !value.trim())) {\n    return true; // join, union, intersection\n  }\n  if (isFunction(token) && isReferenceFunctionName(value)) {\n    return true; // function that yields reference\n  }\n  if (isError(token) && value === '#REF!') {\n    return true;\n  }\n  return false;\n};\n\nconst isReferenceNode = node => {\n  return (!!node) && (\n    (node.type === REFERENCE) ||\n    ((node.type === ERROR_LITERAL || node.type === ERROR) && node.value === '#REF!') ||\n    (node.type === BINARY && (\n      node.operator === ':' ||\n      node.operator === ' ' ||\n      node.operator === ',')\n    ) ||\n    isReference(node) ||\n    (node.type === CALL && isReferenceFunctionName(node.callee.name))\n  );\n};\n\nfunction halt (message: string, atIndex = null) {\n  const err = new Error(message);\n  // @ts-ignore -- FIXME: use a dedicated error class\n  err.source = tokens.map(d => d.value).join('');\n  // @ts-ignore\n  err.sourceOffset = tokens\n    .slice(0, atIndex ?? tokenIndex)\n    .reduce((a, d) => a + d.value.length, 0);\n  throw err;\n}\n\n// A1 A1 | A1 (A1) | A1 ((A1)) | A1 ( (A1) ) | ...\nfunction refIsUpcoming (allowOperators = false): boolean {\n  let i = tokenIndex;\n  let next: Token;\n  do {\n    next = tokens[++i];\n  }\n  while (\n    next && (\n      isWhitespace(next) ||\n      (isOperator(next) && next.value === '(')\n    )\n  );\n  return isReferenceToken(next, allowOperators);\n}\n\nfunction advance (expectNext = null, leftNode = null) {\n  if (expectNext && expectNext !== currentNode.id) {\n    halt(`Expected ${expectNext} but got ${currentNode.id}`);\n  }\n  // look ahead to see if we have ( ( \" \", \"(\" )+ REF )\n  if (isWhitespace(tokens[tokenIndex])) {\n    // potential intersection operation (so don't allow operators as upcoming)\n    const haveRef = isReferenceNode(leftNode);\n    const possibleWSOp = haveRef && refIsUpcoming(false);\n    const nextIsCall = haveRef && tokens[tokenIndex + 1] && tokens[tokenIndex + 1].value === '(';\n    if (!possibleWSOp && !nextIsCall) {\n      // ignore whitespace\n      while (isWhitespace(tokens[tokenIndex])) {\n        tokenIndex++;\n      }\n    }\n  }\n  // EOT\n  if (tokenIndex >= tokens.length) {\n    currentNode = symbolTable[END];\n    return;\n  }\n\n  const token = tokens[tokenIndex];\n  tokenIndex += 1;\n\n  if (token.unterminated) {\n    halt('Encountered an unterminated token');\n  }\n\n  let node;\n  if (isOperator(token)) {\n    node = symbolTable[token.value];\n    if (!node) {\n      halt(`Unknown operator ${token.value}`);\n    }\n  }\n  else if (isWhitespace(token)) {\n    node = symbolTable[WHITESPACE];\n  }\n  else if (isLiteral(token)) {\n    node = symbolTable[LITERAL];\n  }\n  else if (isReference(token)) {\n    node = symbolTable[REFERENCE];\n  }\n  else if (isFunction(token)) {\n    node = symbolTable[FUNCTION];\n  }\n  else {\n    halt(`Unexpected ${token.type} token: ${token.value}`);\n  }\n\n  currentNode = Object.create(node);\n  currentNode.type = token.type;\n  currentNode.value = token.value;\n  if (token.loc) {\n    currentNode.loc = [ ...token.loc ];\n  }\n  return currentNode;\n}\n\nfunction expression (rbp: number) {\n  let t = currentNode;\n  advance(null, t);\n  let left = t.nud();\n  while (rbp < currentNode.lbp) {\n    t = currentNode;\n    advance(null, t);\n    left = t.led(left);\n  }\n  return left;\n}\n\nconst original_symbol = {\n  // null denotation\n  nud: () => halt('Invalid syntax'), // Undefined\n  // left denotation\n  led: () => halt('Missing operator')\n};\n\n// bp = binding power\nfunction symbol (id: string, bp = 0) {\n  let s = symbolTable[id];\n  if (s) {\n    if (bp >= s.lbp) {\n      s.lbp = bp;\n    }\n  }\n  else {\n    s = { ...original_symbol };\n    s.id = id;\n    s.value = id;\n    s.lbp = bp;\n    symbolTable[id] = s;\n  }\n  return s;\n}\n\nfunction infix (id: string, bp: number, led?) {\n  const s = symbol(id, bp);\n  s.led = led || function (this: BinaryExpression & { value?: string }, left) {\n    this.type = BINARY;\n    // @ts-expect-error -- we know this is going to be a valid operator\n    this.operator = this.value;\n    delete this.value;\n    const right = expression(bp);\n    this.arguments = [ left, right ];\n    if (this.loc) {\n      this.loc = [ left.loc[0], right.loc[1] ];\n    }\n    return this;\n  };\n  return s;\n}\n\nfunction postfix (id: string, led?) {\n  const s = symbol(id, 0);\n  s.lbp = 70;\n  s.led = led || function (this: UnaryExpression & { value?: string }, left) {\n    this.type = UNARY;\n    // @ts-expect-error -- we know this is going to be a valid operator\n    this.operator = this.value;\n    delete this.value;\n    this.arguments = [ left ];\n    if (this.loc) {\n      this.loc[0] = left.loc[0];\n    }\n    return this;\n  };\n  return s;\n}\n\nfunction prefix (id, nud?) {\n  const s = symbol(id);\n  s.nud = nud || function (this: UnaryExpression & { value?: string }) {\n    this.type = UNARY;\n    // @ts-expect-error -- we know this is going to be a valid operator\n    this.operator = this.value;\n    delete this.value;\n    const subexpr = expression(70);\n    this.arguments = [ subexpr ];\n    if (this.loc) {\n      this.loc[1] = subexpr.loc[1];\n    }\n    return this;\n  };\n  return s;\n}\n\nfunction rangeInfix (id, bp) {\n  return infix(id, bp, function (this: BinaryExpression & { id?: string, value?: string }, left) {\n    if (!isReferenceNode(left)) {\n      halt(`Unexpected ${id} operator`);\n    }\n    const right = expression(bp);\n    if (!isReferenceNode(right)) {\n      halt(`Unexpected ${currentNode.type} following ${this.id}`);\n    }\n    this.type = BINARY;\n    // @ts-expect-error -- we know this is going to be a valid operator\n    this.operator = this.value.trim() ? this.value : ' '; // hack around whitespace op\n    delete this.value;\n    this.arguments = [ left, right ];\n    if (this.loc) {\n      this.loc = [ left.loc[0], right.loc[1] ];\n    }\n    return this;\n  });\n}\n\nsymbol(END);\n\n// reference operators\nrangeInfix(':', 80); // range join/extend =B7:OFFSET(A1,10,10)\nconst comma = rangeInfix(',', 80); // union =B7:D7,C6:C8\nrangeInfix(WHITESPACE, 80); // intersect: =B7:D7 C6:C8\n\n// Excel's grammar is ambiguous. This turns the , operator's left binding\n// power on/off which allows us to treat , as a symbol where we need.\nconst unionRefs = (enable?: boolean) => {\n  const currState = comma.lbp > 0;\n  if (enable != null) { comma.lbp = enable ? 80 : 0; }\n  return currState;\n};\n\n// arithmetic and string operations\npostfix('%'); // percent\npostfix('#', function (this: Token, left) { // spilled range (_xlfn.ANCHORARRAY)\n  if (!isReferenceNode(left)) {\n    halt('# expects a reference');\n  }\n  this.type = UNARY;\n  this.operator = this.value;\n  delete this.value;\n  this.arguments = [ left ];\n  return this;\n}); // range\nprefix('+'); // unary plus\nprefix('-'); // unary minus\nprefix('@'); // implicit intersection (_xlfn.SINGLE)\ninfix('^', 50); // power\ninfix('*', 40); // multiply\ninfix('/', 40); // divide\ninfix('+', 30); // add\ninfix('-', 30); // subtract\ninfix('&', 20); // text concat\n\n// comparison\ninfix('=', 10);\ninfix('<', 10);\ninfix('>', 10);\ninfix('<=', 10);\ninfix('>=', 10);\ninfix('<>', 10);\nsymbol(LITERAL).nud = function () {\n  const { type, value } = this;\n  this.type = LITERAL;\n  this.raw = value;\n  if (type === NUMBER) {\n    this.value = +value;\n  }\n  else if (type === BOOLEAN) {\n    this.value = value.toUpperCase() === 'TRUE';\n  }\n  else if (type === ERROR) {\n    this.type = ERROR_LITERAL;\n    this.value = value.toUpperCase();\n  }\n  else if (type === STRING) {\n    // FIXME: throw an error if the string is unterminated\n    this.value = value.slice(1, -1).replace(/\"\"/g, '\"');\n  }\n  else {\n    throw new Error('Unsupported literal type: ' + type);\n  }\n  return this;\n};\nsymbol(REFERENCE).nud = function () {\n  if (this.type === REF_NAMED) {\n    this.kind = 'name';\n  }\n  else if (this.type === REF_STRUCT) {\n    this.kind = 'table'; // structured ?\n  }\n  else if (this.type === REF_BEAM) {\n    this.kind = 'beam';\n  }\n  else {\n    this.kind = 'range';\n  }\n  this.type = REFERENCE;\n  return this;\n};\n\n// parens\nsymbol(')');\nprefix('(', function () {\n  const prevState = unionRefs(true);\n  const e = expression(0);\n  advance(')', e);\n  unionRefs(prevState);\n  return e;\n});\n\n// function call\nsymbol(FUNCTION).nud = function () {\n  return this;\n};\ninfix('(', 90, function (this: CallExpression & { value?: string }, left) {\n  let callee: Identifier = {\n    type: IDENTIFIER,\n    name: left.value\n  };\n  if (left.id !== FUNCTION) {\n    if (\n      left.type === LAMBDA ||\n      // Excel only allows calls to \"names\" and ref functions. Since we don't\n      // differentiate between the two (this requires a table of function names)\n      // we're overly permissive here:\n      left.type === CALL ||\n      left.type === LET ||\n      left.type === REFERENCE ||\n      (left.type === UNARY && left.value === '#') || // Because it's really SINGLE(...)()\n      (left.type === ERROR_LITERAL && left.value === '#REF!')\n    ) {\n      // in the case of REFERENCE, do we want to set the node to Identifier?\n      callee = left;\n    }\n    else {\n      halt('Unexpected call', tokenIndex - 1);\n    }\n  }\n  const lcFn = left.value.toLowerCase();\n  if (lcFn === 'lambda') {\n    return parseLambda.call(this, left);\n  }\n  if (lcFn === 'let') {\n    return parseLet.call(this, left);\n  }\n  const args = [];\n  let lastWasComma = false;\n  if (currentNode.id !== ')') {\n    const prevState = unionRefs(false);\n    while (currentNode.id !== ')') {\n      if (isWhitespace(currentNode)) {\n        advance();\n      }\n      if (currentNode.id === ',') {\n        args.push(null);\n        lastWasComma = true;\n        advance();\n      }\n      else {\n        const arg = expression(0);\n        args.push(arg);\n        lastWasComma = false;\n        if (currentNode.id === ',') {\n          advance(',');\n          lastWasComma = true;\n        }\n      }\n    }\n    unionRefs(prevState);\n  }\n  if (lastWasComma) {\n    args.push(null);\n  }\n  const closeParen = currentNode;\n  delete this.value;\n  this.type = CALL;\n  this.callee = callee;\n  if (left.loc) {\n    this.callee.loc = [ ...left.loc ];\n  }\n  this.arguments = args;\n  if (left.loc) {\n    this.loc = [ left.loc[0], closeParen.loc[1] ];\n  }\n  advance(')', this);\n  return this;\n});\n\nfunction parseLambda (this: LambdaExpression & { value?: string }, left) {\n  const args = [];\n  const argNames = {};\n  let body: AstExpression | null;\n  let done = false;\n  const prevState = unionRefs(false);\n  if (currentNode.id !== ')') {\n    while (!done) {\n      if (isWhitespace(currentNode)) {\n        advance();\n      }\n      const argTokenIndex = tokenIndex;\n      const arg = expression(0);\n      if (currentNode.id === ',') {\n        // all but last args must be names\n        if (arg.type === REFERENCE && arg.kind === 'name') {\n          // names may not be duplicates\n          const currName = arg.value.toLowerCase();\n          if (currName in argNames) {\n            halt('Duplicate name: ' + arg.value);\n          }\n          argNames[currName] = 1;\n          const a: Identifier = { type: IDENTIFIER, name: arg.value };\n          if (arg.loc) { a.loc = arg.loc; }\n          args.push(a);\n        }\n        else {\n          tokenIndex = argTokenIndex;\n          halt('LAMBDA argument is not a name');\n        }\n        advance(',');\n      }\n      else {\n        body = arg;\n        done = true;\n      }\n    }\n  }\n  unionRefs(prevState);\n  delete this.value;\n  this.type = LAMBDA;\n  this.params = args;\n  this.body = body || null;\n  if (left.loc) {\n    this.loc = [ left.loc[0], currentNode.loc[1] ];\n  }\n  advance(')', this);\n  return this;\n}\n\nfunction parseLet (this: LetExpression & { value?: string }, left) {\n  const args = [];\n  const vals = [];\n  const argNames = {};\n  let body: AstExpression | null;\n  let argCounter = 0;\n  const addArgument = (arg, lastArg?) => {\n    if (body) {\n      halt('Unexpected argument following calculation');\n    }\n    if (lastArg && argCounter >= 2) {\n      body = arg;\n    }\n    else {\n      const wantName = !(argCounter % 2);\n      if (wantName) {\n        if (arg && (arg.type === REFERENCE && arg.kind === 'name')) {\n          // names may not be duplicates\n          const currName = arg.value.toLowerCase();\n          if (currName in argNames) {\n            halt('Duplicate name: ' + arg.value);\n          }\n          argNames[currName] = 1;\n          args.push({ type: IDENTIFIER, name: arg.value, loc: arg.loc });\n        }\n        else if (argCounter >= 2) {\n          body = arg;\n        }\n        else {\n          halt('Argument is not a name');\n        }\n      }\n      else {\n        vals.push(arg);\n      }\n    }\n    argCounter++;\n  };\n  const prevState = unionRefs(false);\n  let lastWasComma = false;\n  if (currentNode.id !== ')') {\n    while (currentNode.id !== ')') {\n      if (isWhitespace(currentNode)) {\n        advance();\n      }\n      if (currentNode.id === ',') {\n        addArgument(null);\n        lastWasComma = true;\n        advance();\n      }\n      else {\n        const arg = expression(0);\n        addArgument(arg, currentNode.id !== ',');\n        lastWasComma = false;\n        if (currentNode.id === ',') {\n          advance(',');\n          lastWasComma = true;\n        }\n      }\n    }\n    unionRefs(prevState);\n  }\n  if (lastWasComma) {\n    addArgument(null, true);\n  }\n  if (body === undefined) {\n    halt('Unexpected end of arguments');\n  }\n  unionRefs(prevState);\n  delete this.value;\n  this.type = LET;\n  this.declarations = [];\n  if (!args.length) {\n    halt('Unexpected end of arguments');\n  }\n  for (let i = 0; i < args.length; i++) {\n    const s: LetDeclarator = {\n      type: LET_DECL,\n      id: args[i],\n      init: vals[i],\n      loc: args[i].loc && [ args[i].loc[0], vals[i].loc[1] ]\n    };\n    this.declarations.push(s);\n  }\n  this.body = body;\n  if (left.loc) {\n    this.loc = [ left.loc[0], currentNode.loc[1] ];\n  }\n  advance(')', this);\n  return this;\n}\n\n// array literal\nsymbol('}');\nsymbol(';');\nprefix('{', function (this: ArrayExpression & { value?: string }) {\n  if (currentNode.id === '}') { // arrays must not be empty\n    halt('Unexpected empty array');\n  }\n  let row = [];\n  let done = false;\n  const rows = [ row ];\n  const prevState = unionRefs(false);\n  while (!done) {\n    if (isWhitespace(currentNode)) {\n      advance();\n    }\n    // arrays allow only literals, ranges (in GSheets) and ,;: operators.\n    // FIXME: if { negativeNumbers: false } we must consume minuses as well.\n    // Excel allows ={-1} but not ={(-1)} and ={1%}\n    if (isLiteral(currentNode)) {\n      row.push(symbolTable[LITERAL].nud.call(currentNode));\n      advance();\n    }\n    else if (permitArrayRanges && isReferenceNode(currentNode)) {\n      row.push(symbolTable[REFERENCE].nud.call(currentNode));\n      advance();\n    }\n    else if (permitArrayCalls && isFunction(currentNode)) {\n      const arg = expression(0);\n      row.push(arg);\n    }\n    else {\n      halt(`Unexpected ${currentNode.type} in array: ${currentNode.value}`);\n    }\n    if (currentNode.id === ',') {\n      // next item\n      advance(',');\n    }\n    else if (currentNode.id === ';') {\n      // next row\n      advance(';');\n      row = [];\n      rows.push(row);\n    }\n    else {\n      done = true;\n    }\n  }\n  const closingBrace = currentNode;\n  advance('}');\n  unionRefs(prevState);\n  this.type = ARRAY;\n  this.elements = rows;\n  if (this.loc) {\n    this.loc[1] = closingBrace.loc[1];\n  }\n  delete this.value;\n  return this;\n});\n\n/**\n * Options for {@link parse}.\n */\nexport type OptsParse = {\n  /**\n   * Ranges are allowed as elements of arrays. This is a feature in Google Sheets while Excel\n   * does not allow it.\n   * @defaultValue false\n   */\n  permitArrayRanges?: boolean,\n  /**\n   * Function calls are allowed as elements of arrays. This is a feature in Google Sheets\n   * while Excel does not allow it.\n   * @defaultValue false\n   */\n  permitArrayCalls?: boolean,\n  /**\n   * Permits any function call where otherwise only functions that return references would\n   * be permitted.\n   * @defaultValue false\n   */\n  looseRefCalls?: boolean,\n};\n\n/**\n * Parses a string formula or list of tokens into an AST.\n *\n * The parser assumes `mergeRefs` and `negativeNumbers` were `true` when the tokens were generated.\n * It does not yet recognize reference context tokens or know how to deal with unary minuses in\n * arrays.\n *\n * The AST Abstract Syntax Tree's format is documented in\n * [AST_format.md](./AST_format.md).\n *\n * @see {@link OptsParse}\n * @see {@link nodeTypes}\n * @see {@link tokenize}\n * @param tokenlist An array of tokens.\n * @param options Options for the parsers behavior.\n * @returns An AST of nodes.\n */\nexport function parse (\n  tokenlist: Token[],\n  options: OptsParse = {}\n): AstExpression {\n  if (!Array.isArray(tokenlist)) {\n    throw new Error('Parse requires an array of tokens.');\n  }\n  // allow ranges in array \"literals\"?\n  permitArrayRanges = options?.permitArrayRanges;\n  // allow calls in arrays \"literals\"?\n  permitArrayCalls = options?.permitArrayCalls;\n  // allow any function call in range operations?\n  looseRefCalls = options?.looseRefCalls;\n  // assign the tokenlist and set index to start\n  tokens = tokenlist;\n  tokenIndex = 0;\n  // discard redundant whitespace and = prefix\n  while (isWhitespace(tokens[tokenIndex]) || isFxPrefix(tokens[tokenIndex])) {\n    tokenIndex++;\n  }\n  advance();\n  unionRefs(true);\n  const root = expression(0);\n  advance(END);\n  return root;\n}\n","import type {\n  ReferenceA1,\n  ReferenceStruct,\n  ReferenceR1C1,\n  ReferenceA1Xlsx,\n  ReferenceStructXlsx,\n  ReferenceR1C1Xlsx,\n  ReferenceName,\n  ReferenceNameXlsx\n} from './types.ts';\n\nconst reBannedChars = /[^0-9A-Za-z._¡¤§¨ª\\u00ad¯-\\uffff]/;\n// A1-XFD1048575 | R | C | RC\nconst reIsRangelike = /^(R|C|RC|[A-Z]{1,3}\\d{1,7})$/i;\n\nexport function needQuotes (scope: string, yesItDoes = 0): number {\n  if (yesItDoes) {\n    return 1;\n  }\n  if (scope) {\n    if (reBannedChars.test(scope)) {\n      return 1;\n    }\n    if (reIsRangelike.test(scope)) {\n      return 1;\n    }\n    // Sheet/workbook names starting with a digit must be quoted in Excel to\n    // avoid ambiguity with numeric literals.\n    if (/^\\d/.test(scope)) {\n      return 1;\n    }\n  }\n  return 0;\n}\n\nexport function quotePrefix (prefix) {\n  return \"'\" + prefix.replace(/'/g, \"''\") + \"'\";\n}\n\nexport function stringifyPrefix (\n  ref: ReferenceA1 | ReferenceName | ReferenceStruct | ReferenceR1C1\n): string {\n  let pre = '';\n  let quote = 0;\n  let nth = 0;\n  const context = ref.context || [];\n  for (let i = context.length; i > -1; i--) {\n    const scope = context[i];\n    if (scope) {\n      const part = (nth % 2) ? '[' + scope + ']' : scope;\n      pre = part + pre;\n      quote += needQuotes(scope, quote);\n      nth++;\n    }\n  }\n  if (quote) {\n    pre = quotePrefix(pre);\n  }\n  return pre ? pre + '!' : pre;\n}\n\nexport function stringifyPrefixXlsx (\n  ref: ReferenceA1Xlsx | ReferenceNameXlsx | ReferenceStructXlsx | ReferenceR1C1Xlsx\n): string {\n  let pre = '';\n  let quote = 0;\n  const { workbookName, sheetName } = ref;\n  if (workbookName) {\n    pre += '[' + workbookName + ']';\n    quote += needQuotes(workbookName);\n  }\n  if (sheetName) {\n    pre += sheetName;\n    quote += needQuotes(sheetName);\n  }\n  if (quote) {\n    pre = quotePrefix(pre);\n  }\n  return pre ? pre + '!' : pre;\n}\n","import type { RangeA1 } from './types.ts';\n\nexport function toRelative (range: RangeA1): RangeA1 {\n  return Object.assign({}, range, { $left: false, $right: false, $top: false, $bottom: false });\n}\n\nexport function toAbsolute (range: RangeA1): RangeA1 {\n  return Object.assign({}, range, { $left: true, $right: true, $top: true, $bottom: true });\n}\n\nexport function toRow (top: number): string {\n  return String(top + 1);\n}\n\nexport function rangeOperator (trim: 'head' | 'tail' | 'both' | null | undefined): string {\n  if (trim === 'both') {\n    return '.:.';\n  }\n  else if (trim === 'head') {\n    return '.:';\n  }\n  else if (trim === 'tail') {\n    return ':.';\n  }\n  return ':';\n}\n","import { rangeOperator } from './a1.ts';\nimport { MAX_ROWS, MAX_COLS } from './constants.ts';\nimport type { RangeR1C1 } from './types.ts';\n\nconst clamp = (min: number, val: number, max: number) => Math.min(Math.max(val, min), max);\n\nfunction toCoord (value: number, isAbs: boolean): string {\n  if (isAbs) {\n    return String(value + 1);\n  }\n  return value ? '[' + value + ']' : '';\n}\n\n/**\n * Stringify a range object into R1C1 syntax.\n * @internal\n */\nexport function stringifyR1C1Range (range: RangeR1C1): string {\n  let { r0, c0, r1, c1 } = range;\n  const { $c0, $c1, $r0, $r1 } = range;\n  const nullR0 = r0 == null;\n  const nullC0 = c0 == null;\n  let nullR1 = r1 == null;\n  let nullC1 = c1 == null;\n  const op = rangeOperator(range.trim);\n  const hasTrim = !!range.trim;\n  r0 = clamp($r0 ? 0 : -MAX_ROWS, r0 | 0, MAX_ROWS);\n  c0 = clamp($c0 ? 0 : -MAX_COLS, c0 | 0, MAX_COLS);\n  if (!nullR0 && nullR1 && !nullC0 && nullC1) {\n    r1 = r0;\n    nullR1 = false;\n    c1 = c0;\n    nullC1 = false;\n  }\n  else {\n    r1 = clamp($r1 ? 0 : -MAX_ROWS, r1 | 0, MAX_ROWS);\n    c1 = clamp($c1 ? 0 : -MAX_COLS, c1 | 0, MAX_COLS);\n  }\n  // C:C\n  const allRows = r0 === 0 && r1 >= MAX_ROWS;\n  if ((allRows && !nullC0 && !nullC1) || (nullR0 && nullR1)) {\n    const a = toCoord(c0, $c0);\n    const b = toCoord(c1, $c1);\n    return 'C' + (a === b && !hasTrim ? a : a + op + 'C' + b);\n  }\n  // R:R\n  const allCols = c0 === 0 && c1 >= MAX_COLS;\n  if ((allCols && !nullR0 && !nullR1) || (nullC0 && nullC1)) {\n    const a = toCoord(r0, $r0);\n    const b = toCoord(r1, $r1);\n    return 'R' + (a === b && !hasTrim ? a : a + op + 'R' + b);\n  }\n  const s_r0 = toCoord(r0, $r0);\n  const s_r1 = toCoord(r1, $r1);\n  const s_c0 = toCoord(c0, $c0);\n  const s_c1 = toCoord(c1, $c1);\n  // RC:R, RC:C\n  if (nullR0 || nullR1 || nullC0 || nullC1) {\n    return (\n      (nullR0 ? '' : 'R' + s_r0) +\n      (nullC0 ? '' : 'C' + s_c0) +\n      op +\n      (nullR1 ? '' : 'R' + s_r1) +\n      (nullC1 ? '' : 'C' + s_c1)\n    );\n  }\n  // RC:RC\n  if (s_r0 !== s_r1 || s_c0 !== s_c1) {\n    return 'R' + s_r0 + 'C' + s_c0 + op + 'R' + s_r1 + 'C' + s_c1;\n  }\n  // RC\n  return 'R' + s_r0 + 'C' + s_c0;\n}\n","/*\n** RC notation works differently from A1 in that we can't merge static\n** references joined by `:`. Merging can only work between references\n** that are relative/absolute on the same axes, so:\n** - R1C1:R2C2 will work,\n** - R[1]C1:R[2]C2 will also work, but\n** - R[1]C[1]:R2C2 doesn't have a direct rectangle represention without context.\n*/\nimport type { ReferenceName, ReferenceNameXlsx, ReferenceR1C1, ReferenceR1C1Xlsx } from './types.ts';\nimport { stringifyPrefix, stringifyPrefixXlsx } from './stringifyPrefix.ts';\nimport { stringifyR1C1Range } from './stringifyR1C1Range.ts';\n\n/**\n * Get an R1C1-style string representation of a reference object.\n *\n * ```js\n * stringifyR1C1Ref({\n *   context: [ 'Sheet1' ],\n *   range: {\n *     r0: 9,\n *     c0: 8,\n *     r1: 9,\n *     c1: 8,\n *     $c0: true,\n *     $c1: true\n *     $r0: false,\n *     $r1: false\n *   }\n * });\n * // => 'Sheet1!R[9]C9:R[9]C9'\n * ```\n *\n * @param refObject A reference object.\n * @returns The reference in R1C1-style string format.\n */\nexport function stringifyR1C1Ref (refObject: ReferenceR1C1 | ReferenceName): string {\n  const prefix = stringifyPrefix(refObject);\n  return prefix + ('name' in refObject ? refObject.name : stringifyR1C1Range(refObject.range));\n}\n\n/**\n * Get an R1C1-style string representation of a reference object.\n *\n * ```js\n * stringifyR1C1Ref({\n *   sheetName: 'Sheet1',\n *   range: {\n *     r0: 9,\n *     c0: 8,\n *     r1: 9,\n *     c1: 8,\n *     $c0: true,\n *     $c1: true\n *     $r0: false,\n *     $r1: false\n *   }\n * });\n * // => 'Sheet1!R[9]C9:R[9]C9'\n * ```\n *\n * @param refObject A reference object.\n * @returns The reference in R1C1-style string format.\n */\nexport function stringifyR1C1RefXlsx (refObject: ReferenceR1C1Xlsx | ReferenceNameXlsx): string {\n  const prefix = stringifyPrefixXlsx(refObject);\n  return prefix + ('name' in refObject ? refObject.name : stringifyR1C1Range(refObject.range));\n}\n","import { MAX_COLS, MAX_ROWS } from './constants.ts';\nimport type { RangeA1 } from './types.ts';\n\ntype TrimString = 'both' | 'head' | 'tail';\n\nexport function fromRow (rowStr: string): number {\n  return +rowStr - 1;\n}\n\nconst CHAR_DOLLAR = 36;\nconst CHAR_PERIOD = 46;\nconst CHAR_COLON = 58;\nconst CHAR_A_LC = 97;\nconst CHAR_A_UC = 65;\nconst CHAR_Z_LC = 122;\nconst CHAR_Z_UC = 90;\nconst CHAR_0 = 48;\nconst CHAR_1 = 49;\nconst CHAR_9 = 57;\n\nfunction advRangeOp (str: string, pos: number): [ number, TrimString | '' ] {\n  const c0 = str.charCodeAt(pos);\n  if (c0 === CHAR_PERIOD) {\n    const c1 = str.charCodeAt(pos + 1);\n    if (c1 === CHAR_COLON) {\n      return str.charCodeAt(pos + 2) === CHAR_PERIOD\n        ? [ 3, 'both' ]\n        : [ 2, 'head' ];\n    }\n  }\n  else if (c0 === CHAR_COLON) {\n    const c1 = str.charCodeAt(pos + 1);\n    return c1 === CHAR_PERIOD\n      ? [ 2, 'tail' ]\n      : [ 1, '' ];\n  }\n  return [ 0, '' ];\n}\n\nfunction advA1Col (str: string, pos: number): [ number, number, boolean ] {\n  // [A-Z]{1,3}\n  const start = pos;\n  const lock = str.charCodeAt(pos) === CHAR_DOLLAR;\n  if (lock) { pos++; }\n  const stop = pos + 3;\n  let col = 0;\n  do {\n    const c = str.charCodeAt(pos);\n    if (c >= CHAR_A_UC && c <= CHAR_Z_UC) {\n      col = (26 * col) + c - (CHAR_A_UC - 1);\n      pos++;\n    }\n    else if (c >= CHAR_A_LC && c <= CHAR_Z_LC) {\n      col = (26 * col) + c - (CHAR_A_LC - 1);\n      pos++;\n    }\n    else {\n      break;\n    }\n  }\n  while (pos < stop && pos < str.length);\n  return (col && col <= MAX_COLS + 1)\n    ? [ pos - start, col - 1, lock ]\n    : [ 0, 0, false ];\n}\n\nfunction advA1Row (str: string, pos: number): [number, number, boolean] {\n  // [1-9][0-9]{0,6}\n  const start = pos;\n  const lock = str.charCodeAt(pos) === CHAR_DOLLAR;\n  if (lock) { pos++; }\n  const stop = pos + 7;\n  let row = 0;\n  let c = str.charCodeAt(pos);\n  if (c >= CHAR_1 && c <= CHAR_9) {\n    row = (row * 10) + c - CHAR_0;\n    pos++;\n    do {\n      c = str.charCodeAt(pos);\n      if (c >= CHAR_0 && c <= CHAR_9) {\n        row = (row * 10) + c - CHAR_0;\n        pos++;\n      }\n      else {\n        break;\n      }\n    }\n    while (pos < stop && pos < str.length);\n  }\n  return (row && row <= MAX_ROWS + 1)\n    ? [ pos - start, row - 1, lock ]\n    : [ 0, 0, false ];\n}\n\nfunction makeRange (\n  top: number | null,\n  $top: boolean | null,\n  left: number | null,\n  $left: boolean | null,\n  bottom: number | null,\n  $bottom: boolean | null,\n  right: number | null,\n  $right: boolean | null,\n  trim: TrimString | ''\n): RangeA1 {\n  // flip left/right and top/bottom as needed\n  // for partial ranges we perfer the coord on the left-side of the:\n  if (right != null && (left == null || (left != null && right < left))) {\n    [ left, right, $left, $right ] = [ right, left, $right, $left ];\n  }\n  if (bottom != null && (top == null || (top != null && bottom < top))) {\n    [ top, bottom, $top, $bottom ] = [ bottom, top, $bottom, $top ];\n  }\n  const range: RangeA1 = { top, left, bottom, right, $top, $left, $bottom, $right };\n  if (trim) {\n    range.trim = trim;\n  }\n  return range;\n}\n\n/**\n * Parse A1-style range string into a RangeA1 object.\n *\n * @param rangeString A1-style range string.\n * @param [allowTernary] Permit ternary ranges like A2:A or B2:2.\n * @return A reference object.\n */\nexport function parseA1Range (rangeString: string, allowTernary = true): RangeA1 | undefined {\n  let p = 0;\n  const [ leftChars, left, $left ] = advA1Col(rangeString, p);\n  let right = 0;\n  let $right = false;\n  let bottom = 0;\n  let $bottom = false;\n  let rightChars: number;\n  let bottomChars: number;\n  if (leftChars) {\n    // TLBR: could be A1:A1\n    // TL R: could be A1:A (if allowTernary)\n    // TLB : could be A1:1 (if allowTernary)\n    //  LBR: could be A:A1 (if allowTernary)\n    //  L R: could be A:A\n    p += leftChars;\n    const [ topChars, top, $top ] = advA1Row(rangeString, p);\n    p += topChars;\n    const [ op, trim ] = advRangeOp(rangeString, p);\n    if (op) {\n      p += op;\n      [ rightChars, right, $right ] = advA1Col(rangeString, p);\n      p += rightChars;\n      [ bottomChars, bottom, $bottom ] = advA1Row(rangeString, p);\n      p += bottomChars;\n      if (topChars && bottomChars && rightChars) {\n        if (p === rangeString.length) {\n          return makeRange(top, $top, left, $left, bottom, $bottom, right, $right, trim);\n        }\n      }\n      else if (!topChars && !bottomChars) {\n        if (p === rangeString.length) {\n          return makeRange(null, false, left, $left, null, false, right, $right, trim);\n        }\n      }\n      else if (allowTernary && (bottomChars || rightChars) && p === rangeString.length) {\n        if (!topChars) {\n          return makeRange(null, false, left, $left, bottom, $bottom, right, $right, trim);\n        }\n        else if (!bottomChars) {\n          return makeRange(top, $top, left, $left, null, false, right, $right, trim);\n        }\n        else {\n          return makeRange(top, $top, left, $left, bottom, $bottom, null, false, trim);\n        }\n      }\n    }\n    // LT  : this is A1\n    if (topChars && p === rangeString.length) {\n      return makeRange(top, $top, left, $left, top, $top, left, $left, trim);\n    }\n  }\n  else {\n    // T B : could be 1:1\n    // T BR: could be 1:A1 (if allowTernary)\n    const [ topChars, top, $top ] = advA1Row(rangeString, p);\n    if (topChars) {\n      p += topChars;\n      const [ op, trim ] = advRangeOp(rangeString, p);\n      if (op) {\n        p += op;\n        [ rightChars, right, $right ] = advA1Col(rangeString, p);\n        p += rightChars;\n        [ bottomChars, bottom, $bottom ] = advA1Row(rangeString, p);\n        p += bottomChars;\n        if (rightChars && bottomChars && allowTernary) {\n          if (p === rangeString.length) {\n            return makeRange(top, $top, null, false, bottom, $bottom, right, $right, trim);\n          }\n        }\n        else if (!rightChars && bottomChars) {\n          if (p === rangeString.length) {\n            return makeRange(top, $top, null, false, bottom, $bottom, null, false, trim);\n          }\n        }\n      }\n    }\n  }\n}\n","import type { Token } from './types.ts';\n\n/**\n * Collapses a list of tokens into a formula string.\n *\n * @param tokens A list of tokens.\n * @returns A formula string.\n */\nexport function stringifyTokens (tokens: Token[]): string {\n  let s = '';\n  for (const token of tokens) {\n    s += token.value;\n  }\n  return s;\n}\n","import type { Token, TokenEnhanced } from './types.ts';\n\nexport function cloneToken<T extends Token | TokenEnhanced> (token: T): T {\n  // Token\n  const newToken: Partial<TokenEnhanced> = {\n    type: token.type,\n    value: token.value\n  };\n  if (token.loc) {\n    newToken.loc = [ token.loc[0], token.loc[1] ];\n  }\n  if (token.unterminated != null) {\n    newToken.unterminated = token.unterminated;\n  }\n  // TokenEnhanced\n  if (typeof token.index === 'number') {\n    newToken.index = token.index;\n    if (typeof token.groupId === 'string') {\n      newToken.groupId = token.groupId;\n    }\n    if (typeof token.depth === 'number') {\n      newToken.depth = token.depth;\n    }\n    if (typeof token.error === 'boolean') {\n      newToken.error = token.error;\n    }\n  }\n  return newToken as T;\n}\n","import {\n  FX_PREFIX,\n  CONTEXT,\n  CONTEXT_QUOTE,\n  REF_RANGE,\n  REF_TERNARY,\n  REF_NAMED,\n  REF_BEAM,\n  REF_STRUCT,\n  OPERATOR\n} from './constants.ts';\nimport { lexersRefs } from './lexers/sets.ts';\nimport { getTokens } from './tokenize.ts';\nimport type { Token } from './types.ts';\n\n// Liberally split a context string up into parts.\n// Permits any combination of braced and unbraced items.\nexport function splitPrefix (str: string, stringsOnly = false) {\n  let inBrace = false;\n  let currStr = '';\n  const parts = [];\n  const flush = () => {\n    if (currStr) {\n      parts.push(\n        stringsOnly\n          ? currStr\n          : { value: currStr, braced: inBrace }\n      );\n    }\n    currStr = '';\n  };\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < str.length; i++) {\n    const char = str[i];\n    if (char === '[') {\n      flush();\n      inBrace = true;\n    }\n    else if (char === ']') {\n      flush();\n      inBrace = false;\n    }\n    else {\n      currStr += char;\n    }\n  }\n  flush();\n  return parts;\n}\n\nexport function splitContext (contextString, data, xlsx) {\n  const ctx = splitPrefix(contextString, !xlsx);\n  if (xlsx) {\n    if (ctx.length > 1) {\n      data.workbookName = ctx[ctx.length - 2].value;\n      data.sheetName = ctx[ctx.length - 1].value;\n    }\n    else if (ctx.length === 1) {\n      const item = ctx[0];\n      if (item.braced) {\n        data.workbookName = item.value;\n      }\n      else {\n        data.sheetName = item.value;\n      }\n    }\n  }\n  else {\n    data.context = ctx;\n  }\n}\n\ntype RefParseData = {\n  operator: string,\n  r0: string,\n  r1: string,\n  name: string,\n  struct: string,\n};\ntype RefParserPart = (t: Token | undefined, data: Partial<RefParseData>, xlsx?: boolean) => 1 | undefined;\n\nconst unquote = d => d.slice(1, -1).replace(/''/g, \"'\");\n\nconst pRangeOp: RefParserPart = (t, data) => {\n  const value = t?.value;\n  if (value === ':' || value === '.:' || value === ':.' || value === '.:.') {\n    data.operator = value;\n    return 1;\n  }\n};\nconst pRange: RefParserPart = (t, data) => {\n  if (t?.type === REF_RANGE) {\n    data.r0 = t.value;\n    return 1;\n  }\n};\nconst pPartial: RefParserPart = (t, data) => {\n  if (t?.type === REF_TERNARY) {\n    data.r0 = t.value;\n    return 1;\n  }\n};\nconst pRange2: RefParserPart = (t, data) => {\n  if (t?.type === REF_RANGE) {\n    data.r1 = t.value;\n    return 1;\n  }\n};\nconst pBang: RefParserPart = t => {\n  if (t?.type === OPERATOR && t.value === '!') {\n    return 1;\n  }\n};\nconst pBeam: RefParserPart = (t, data) => {\n  if (t?.type === REF_BEAM) {\n    data.r0 = t.value;\n    return 1;\n  }\n};\nconst pStrucured: RefParserPart = (t, data) => {\n  if (t.type === REF_STRUCT) {\n    data.struct = t.value;\n    return 1;\n  }\n};\nconst pContext: RefParserPart = (t, data, xlsx) => {\n  const type = t?.type;\n  if (type === CONTEXT) {\n    splitContext(t.value, data, xlsx);\n    return 1;\n  }\n  if (type === CONTEXT_QUOTE) {\n    splitContext(unquote(t.value), data, xlsx);\n    return 1;\n  }\n};\nconst pNamed: RefParserPart = (t, data) => {\n  if (t?.type === REF_NAMED) {\n    data.name = t.value;\n    return 1;\n  }\n};\n\nconst validRuns = [\n  [ pPartial ],\n  [ pRange, pRangeOp, pRange2 ],\n  [ pRange ],\n  [ pBeam ],\n  [ pContext, pBang, pPartial ],\n  [ pContext, pBang, pRange, pRangeOp, pRange2 ],\n  [ pContext, pBang, pRange ],\n  [ pContext, pBang, pBeam ]\n];\n\nconst validRunsNamed = validRuns.concat([\n  [ pNamed ],\n  [ pContext, pBang, pNamed ],\n  [ pStrucured ],\n  [ pNamed, pStrucured ],\n  [ pContext, pBang, pNamed, pStrucured ]\n]);\n\ntype ParseRefOptions = {\n  withLocation?: boolean,\n  mergeRefs?: boolean,\n  allowTernary?: boolean,\n  allowNamed?: boolean,\n  r1c1?: boolean,\n};\nexport type RefParseDataXls = RefParseData & { workbookName: string, sheetName: string };\nexport type RefParseDataCtx = RefParseData & { context: string[] };\n\nexport function parseRefCtx (ref: string, opts: ParseRefOptions = {}): RefParseDataCtx | null {\n  const options = {\n    withLocation: opts.withLocation ?? false,\n    mergeRefs: opts.mergeRefs ?? false,\n    allowTernary: opts.allowTernary ?? false,\n    allowNamed: opts.allowNamed ?? true,\n    r1c1: opts.r1c1 ?? false\n  };\n  const tokens = getTokens(ref, lexersRefs, options);\n\n  // discard the \"=\"-prefix if it is there\n  if (tokens.length && tokens[0].type === FX_PREFIX) {\n    tokens.shift();\n  }\n  const runs = options.allowNamed ? validRunsNamed : validRuns;\n  for (const run of runs) {\n    // const len = run.length;\n    if (run.length === tokens.length) {\n      const data: RefParseDataCtx = {\n        context: [],\n        r0: '',\n        r1: '',\n        name: '',\n        struct: '',\n        operator: ''\n      };\n      const valid = run.every((parse, i) => parse(tokens[i], data, false));\n      if (valid) {\n        return data;\n      }\n    }\n  }\n}\n\nexport function parseRefXlsx (ref: string, opts: ParseRefOptions = {}): RefParseDataXls | null {\n  const options = {\n    withLocation: opts.withLocation ?? false,\n    mergeRefs: opts.mergeRefs ?? false,\n    allowTernary: opts.allowTernary ?? false,\n    allowNamed: opts.allowNamed ?? true,\n    r1c1: opts.r1c1 ?? false,\n    xlsx: true\n  };\n  const tokens = getTokens(ref, lexersRefs, options);\n\n  // discard the \"=\"-prefix if it is there\n  if (tokens.length && tokens[0].type === FX_PREFIX) {\n    tokens.shift();\n  }\n  const runs = options.allowNamed ? validRunsNamed : validRuns;\n  for (const run of runs) {\n    if (run.length === tokens.length) {\n      const data: RefParseDataXls = {\n        workbookName: '',\n        sheetName: '',\n        r0: '',\n        r1: '',\n        name: '',\n        struct: '',\n        operator: ''\n      };\n      const valid = run.every((parse, i) => parse(tokens[i], data, true));\n      if (valid) {\n        return data as any;\n      }\n    }\n  }\n}\n","import { stringifyR1C1RefXlsx } from './stringifyR1C1Ref.ts';\nimport { tokenizeXlsx } from './tokenize.ts';\nimport { parseA1Range } from './parseA1Range.ts';\nimport type { RangeR1C1, ReferenceA1Xlsx, Token } from './types.ts';\nimport { stringifyTokens } from './stringifyTokens.ts';\nimport { cloneToken } from './cloneToken.ts';\nimport { FUNCTION, OPERATOR, REF_BEAM, REF_RANGE, REF_TERNARY } from './constants.ts';\nimport { splitContext } from './parseRef.ts';\nimport { isRCTokenValue } from './isRCTokenValue.ts';\n\nconst reLetLambda = /^l(?:ambda|et)$/i;\n\nconst calc = (abs: boolean, vX: number, aX: number): number => {\n  if (vX == null) {\n    return null;\n  }\n  return abs ? vX : vX - aX;\n};\n\n// We already know here that we're holding a token value from\n// one of: REF_RANGE | REF_BEAM | REF_TERNARY\n// So we can quickly scan for ! shortcut a bunch of parsing:\nconst unquote = d => d.slice(1, -1).replace(/''/g, \"'\");\nfunction quickParseA1 (ref: string): ReferenceA1Xlsx {\n  const split = ref.lastIndexOf('!');\n  const data: Partial<ReferenceA1Xlsx> = {};\n  if (split > -1) {\n    if (ref.startsWith('\\'')) {\n      splitContext(unquote(ref.slice(0, split)), data, true);\n    }\n    else {\n      splitContext(ref.slice(0, split), data, true);\n    }\n    data.range = parseA1Range(ref.slice(split + 1));\n  }\n  else {\n    data.range = parseA1Range(ref);\n  }\n  return data as ReferenceA1Xlsx;\n}\n\n/**\n * Options for {@link translateFormulaToR1C1}.\n */\nexport type OptsTranslateToR1C1 = {\n  /**\n   * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.\n   * These are supported by Google Sheets but not Excel.\n   * See: [References.md](./References.md).\n   * @defaultValue true\n   */\n  allowTernary?: boolean,\n};\n\n/**\n * Translates ranges in a list of tokens from absolute A1 syntax to relative R1C1 syntax.\n *\n * ```js\n * translateFormulaToR1C1(\"=SUM(E10,$E$2,Sheet!$E$3)\", \"D10\");\n * // => \"=SUM(RC[1],R2C5,Sheet!R3C5)\");\n * ```\n *\n * @param tokens A token list that should be adjusted.\n * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).\n * @returns A token list.\n */\nexport function translateTokensToR1C1 (\n  tokens: Token[],\n  anchorCell: string\n): Token[] {\n  const anchorRange = parseA1Range(anchorCell);\n  if (!anchorRange) {\n    throw new Error('translateTokensToR1C1 got an invalid anchorCell: ' + anchorCell);\n  }\n  const { top, left } = anchorRange;\n  let withinCall = 0;\n  let parenDepth = 0;\n\n  let offsetSkew = 0;\n  const outTokens: Token[] = [];\n  for (let token of tokens) {\n    const tokenType = token?.type;\n    if (tokenType === OPERATOR) {\n      if (token.value === '(') {\n        parenDepth++;\n        const lastToken = outTokens[outTokens.length - 1];\n        if (lastToken && lastToken.type === FUNCTION) {\n          if (reLetLambda.test(lastToken.value)) {\n            withinCall = parenDepth;\n          }\n        }\n      }\n      else if (token.value === ')') {\n        parenDepth--;\n        if (parenDepth < withinCall) {\n          withinCall = 0;\n        }\n      }\n    }\n    if (tokenType === REF_RANGE || tokenType === REF_BEAM || tokenType === REF_TERNARY) {\n      token = cloneToken(token);\n      const tokenValue = token.value;\n      // We can get away with using the xlsx ref-parser here because it is more permissive:\n      const ref = quickParseA1(tokenValue);\n      if (ref) {\n        const d = ref.range;\n        const range: RangeR1C1 = {};\n        range.r0 = calc(d.$top, d.top, top);\n        range.r1 = calc(d.$bottom, d.bottom, top);\n        range.c0 = calc(d.$left, d.left, left);\n        range.c1 = calc(d.$right, d.right, left);\n        range.$r0 = d.$top;\n        range.$r1 = d.$bottom;\n        range.$c0 = d.$left;\n        range.$c1 = d.$right;\n        if (d.trim) {\n          range.trim = d.trim;\n        }\n        // @ts-expect-error -- reusing the object, switching it to R1C1 by swapping the range\n        ref.range = range;\n        let val = stringifyR1C1RefXlsx(ref);\n        if (isRCTokenValue(val) && withinCall) {\n          val += '[0]';\n        }\n        token.value = val;\n      }\n      // if token includes offsets, those offsets are now likely wrong!\n      if (token.loc) {\n        token.loc[0] += offsetSkew;\n        offsetSkew += token.value.length - tokenValue.length;\n        token.loc[1] += offsetSkew;\n      }\n    }\n    else if (offsetSkew && token.loc) {\n      token = cloneToken(token);\n      token.loc[0] += offsetSkew;\n      token.loc[1] += offsetSkew;\n    }\n    outTokens[outTokens.length] = token;\n  }\n\n  return outTokens;\n}\n\n/**\n * Translates ranges in a formula from absolute A1 syntax to relative R1C1 syntax.\n *\n * ```js\n * translateFormulaToR1C1(\"=SUM(E10,$E$2,Sheet!$E$3)\", \"D10\");\n * // => \"=SUM(RC[1],R2C5,Sheet!R3C5)\");\n * ```\n *\n * @see {@link OptsTranslateToR1C1}\n * @param formula An Excel formula that should be adjusted.\n * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).\n * @param [options={}] The options\n * @returns A formula string.\n */\nexport function translateFormulaToR1C1 (\n  formula: string,\n  anchorCell: string,\n  options: OptsTranslateToR1C1 = {}\n): string {\n  if (typeof formula === 'string') {\n    const tokens = tokenizeXlsx(formula, {\n      mergeRefs: false,\n      allowTernary: options.allowTernary ?? true\n    });\n    return stringifyTokens(translateTokensToR1C1(tokens, anchorCell));\n  }\n  throw new Error('translateFormulaToA1 expects a formula string');\n}\n","const charFrom = String.fromCharCode;\n\n/**\n * Convert a 0 based offset number to a column string\n * representation (`0` = `\"A\"`, `2` = `\"C\"`).\n *\n * The method expects a number between 0 and 16383. Other input will\n * return garbage.\n *\n * @param columnIndex Zero based column index number\n * @returns The column string identifier\n */\nexport function toCol (columnIndex: number): string {\n  return (\n    (columnIndex >= 702\n      ? charFrom(((((columnIndex - 702) / 676) - 0) % 26) + 65)\n      : '') +\n    (columnIndex >= 26\n      ? charFrom(((((columnIndex / 26) - 1) % 26) + 65))\n      : '') +\n    charFrom((columnIndex % 26) + 65)\n  );\n}\n","import { MAX_ROWS, MAX_COLS } from './constants.ts';\nimport { toCol } from './toCol.ts';\nimport type { RangeA1 } from './types.ts';\nimport { rangeOperator } from './a1.ts';\n\nconst clamp = (min: number, val: number, max: number) => Math.min(Math.max(val, min), max);\nconst toColStr = (c: number, a: boolean) => (a ? '$' : '') + toCol(c);\nconst toRowStr = (r: number, a: boolean) => (a ? '$' : '') + toRow(r);\nconst toRow = (top: number): string => String(top + 1);\n\n/**\n * Stringify a range object into A1 syntax.\n * @param range A range object\n * @returns An A1-style string represenation of a range\n * @internal\n */\nexport function stringifyA1Range (range: Partial<RangeA1>): string {\n  // eslint-disable-next-line prefer-const\n  let { top, left, bottom, right, trim } = range;\n  const { $left, $right, $top, $bottom } = range;\n  const noLeft = left == null;\n  const noRight = right == null;\n  const noTop = top == null;\n  const noBottom = bottom == null;\n  // allow skipping right and bottom to define a cell\n  top = clamp(0, top | 0, MAX_ROWS);\n  left = clamp(0, left | 0, MAX_COLS);\n  if (!noLeft && !noTop && noRight && noBottom) {\n    bottom = top;\n    right = left;\n  }\n  else {\n    bottom = clamp(0, bottom | 0, MAX_ROWS);\n    right = clamp(0, right | 0, MAX_COLS);\n  }\n  const op = rangeOperator(trim);\n  // A:A\n  const allRows = top === 0 && bottom >= MAX_ROWS;\n  const haveAbsCol = ($left && !noLeft) || ($right && !noRight);\n  if ((allRows && !noLeft && !noRight && (!haveAbsCol || left === right)) || (noTop && noBottom)) {\n    return toColStr(left, $left) + op + toColStr(right, $right);\n  }\n  // 1:1\n  const allCols = left === 0 && right >= MAX_COLS;\n  const haveAbsRow = ($top && !noTop) || ($bottom && !noBottom);\n  if ((allCols && !noTop && !noBottom && (!haveAbsRow || top === bottom)) || (noLeft && noRight)) {\n    return toRowStr(top, $top) + op + toRowStr(bottom, $bottom);\n  }\n  // A1:1\n  if (!noLeft && !noTop && !noRight && noBottom) {\n    return toColStr(left, $left) + toRowStr(top, $top) + op + toColStr(right, $right);\n  }\n  // A:A1 => A1:1\n  if (!noLeft && noTop && !noRight && !noBottom) {\n    return toColStr(left, $left) + toRowStr(bottom, $bottom) + op + toColStr(right, $right);\n  }\n  // A1:A\n  if (!noLeft && !noTop && noRight && !noBottom) {\n    return toColStr(left, $left) + toRowStr(top, $top) + op + toRowStr(bottom, $bottom);\n  }\n  // A:A1 => A1:A\n  if (noLeft && !noTop && !noRight && !noBottom) {\n    return toColStr(right, $right) + toRowStr(top, $top) + op + toRowStr(bottom, $bottom);\n  }\n  // A1:A1\n  if (right !== left || bottom !== top || $right !== $left || $bottom !== $top) {\n    return toColStr(left, $left) + toRowStr(top, $top) + op +\n           toColStr(right, $right) + toRowStr(bottom, $bottom);\n  }\n  // A1\n  return toColStr(left, $left) + toRowStr(top, $top);\n}\n","import { stringifyPrefix, stringifyPrefixXlsx } from './stringifyPrefix.ts';\nimport type { ReferenceA1, ReferenceA1Xlsx, ReferenceName, ReferenceNameXlsx } from './types.ts';\nimport { stringifyA1Range } from './stringifyA1Range.ts';\n\n/**\n * Get an A1-style string representation of a reference object.\n *\n * ```js\n * stringifyA1Ref({\n *   context: [ 'Sheet1' ],\n *   range: {\n *     top: 0,\n *     left: 0,\n *     bottom: 1,\n *     right: 1,\n *     $top: true,\n *     $left: false,\n *     $bottom: false,\n *     $right: true\n *   }\n * });\n * // => 'Sheet1!A$1:$B2'\n * ```\n *\n * @param refObject A reference object.\n * @returns The reference in A1-style string format.\n */\nexport function stringifyA1Ref (refObject: ReferenceA1 | ReferenceName): string {\n  const prefix = stringifyPrefix(refObject);\n  return prefix + ('name' in refObject ? refObject.name : stringifyA1Range(refObject.range));\n}\n\n/**\n * Get an A1-style string representation of a reference object.\n *\n * ```js\n * stringifyA1Ref({\n *   sheetName: 'Sheet1',\n *   range: {\n *     top: 0,\n *     left: 0,\n *     bottom: 1,\n *     right: 1,\n *     $top: true,\n *     $left: false,\n *     $bottom: false,\n *     $right: true\n *   }\n * });\n * // => 'Sheet1!A$1:$B2'\n * ```\n *\n * @param refObject A reference object.\n * @returns The reference in A1-style string format.\n */\nexport function stringifyA1RefXlsx (refObject: ReferenceA1Xlsx | ReferenceNameXlsx): string {\n  const prefix = stringifyPrefixXlsx(refObject);\n  return prefix + ('name' in refObject ? refObject.name : stringifyA1Range(refObject.range));\n}\n","/*\n** RC notation works differently from A1 in that we can't merge static\n** references joined by `:`. Merging can only work between references\n** that are relative/absolute on the same axes, so:\n** - R1C1:R2C2 will work,\n** - R[1]C1:R[2]C2 will also work, but\n** - R[1]C[1]:R2C2 doesn't have a direct rectangle represention without context.\n*/\nimport type { RangeR1C1 } from './types.ts';\n\nfunction trimDirection (head: boolean, tail: boolean): 'both' | 'head' | 'tail' | undefined {\n  if (head && tail) {\n    return 'both';\n  }\n  if (head) {\n    return 'head';\n  }\n  if (tail) {\n    return 'tail';\n  }\n}\n\nfunction parseR1C1Part (ref: string): [number, number, boolean, boolean] {\n  let r0 = null;\n  let c0 = null;\n  let $r0 = null;\n  let $c0 = null;\n  // R part\n  const rm = /^R(?:\\[([+-]?\\d+)\\]|(\\d+))?/.exec(ref);\n  if (rm) {\n    if (rm[1]) {\n      r0 = parseInt(rm[1], 10);\n      $r0 = false;\n    }\n    else if (rm[2]) {\n      r0 = parseInt(rm[2], 10) - 1;\n      $r0 = true;\n    }\n    else {\n      r0 = 0;\n      $r0 = false;\n    }\n    ref = ref.slice(rm[0].length);\n  }\n  // C part\n  const cm = /^C(?:\\[([+-]?\\d+)\\]|(\\d+))?/.exec(ref);\n  if (cm) {\n    if (cm[1]) {\n      c0 = parseInt(cm[1], 10);\n      $c0 = false;\n    }\n    else if (cm[2]) {\n      c0 = parseInt(cm[2], 10) - 1;\n      $c0 = true;\n    }\n    else {\n      c0 = 0;\n      $c0 = false;\n    }\n    ref = ref.slice(cm[0].length);\n  }\n  // must have at least one part (and nothing more)\n  if ((!rm && !cm) || ref.length) {\n    return null;\n  }\n  return [ r0, c0, $r0, $c0 ];\n}\n\n/**\n * Parse R1C1-style range string into a RangeR1C1 object.\n *\n * @param rangeString R1C1-style range string.\n * @return A reference object.\n */\nexport function parseR1C1Range (rangeString: string): RangeR1C1 | null {\n  let final: RangeR1C1 | null = undefined;\n  const [ part1, op, part2, overflow ] = rangeString.split(/(\\.?:\\.?)/);\n  if (overflow) {\n    return null;\n  }\n  const range = parseR1C1Part(part1);\n  // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with\n  const trim = trimDirection(!!op && op[0] === '.', !!op && op[op.length - 1] === '.');\n  if (range) {\n    const [ r0, c0, $r0, $c0 ] = range;\n    if (part2) {\n      const extendTo = parseR1C1Part(part2);\n      if (extendTo) {\n        final = {};\n        const [ r1, c1, $r1, $c1 ] = extendTo;\n        // rows\n        if (r0 != null && r1 != null) {\n          final.r0 = $r0 === $r1 ? Math.min(r0, r1) : r0;\n          final.$r0 = $r0;\n          final.r1 = $r0 === $r1 ? Math.max(r0, r1) : r1;\n          final.$r1 = $r1;\n        }\n        else if (r0 != null && r1 == null) {\n          // partial RC:C\n          final.r0 = r0;\n          final.$r0 = $r0;\n          final.r1 = null;\n          final.$r1 = $r0;\n        }\n        else if (r0 == null && r1 != null) {\n          // partial C:RC\n          final.r0 = r1;\n          final.$r0 = $r1;\n          final.r1 = null;\n          final.$r1 = $r1;\n        }\n        else if (r0 == null && r1 == null) {\n          // C:C\n          final.r0 = null;\n          final.$r0 = false;\n          final.r1 = null;\n          final.$r1 = false;\n        }\n        // columns\n        if (c0 != null && c1 != null) {\n          final.c0 = $c0 === $c1 ? Math.min(c0, c1) : c0;\n          final.$c0 = $c0;\n          final.c1 = $c0 === $c1 ? Math.max(c0, c1) : c1;\n          final.$c1 = $c1;\n        }\n        else if (c0 != null && c1 == null) {\n          final.c0 = c0;\n          final.$c0 = $c0;\n          final.c1 = null;\n          final.$c1 = $c0;\n        }\n        else if (c0 == null && c1 != null) {\n          final.c0 = c1;\n          final.$c0 = $c1;\n          final.c1 = null;\n          final.$c1 = $c1;\n        }\n        else if (c0 == null && c1 == null) {\n          final.c0 = null;\n          final.$c0 = false;\n          final.c1 = null;\n          final.$c1 = false;\n        }\n      }\n      else {\n        return null;\n      }\n    }\n    // range only - no second part\n    else if (r0 != null && c0 == null) {\n      final = {\n        r0: r0,\n        c0: null,\n        r1: r0,\n        c1: null,\n        $r0: $r0,\n        $c0: false,\n        $r1: $r0,\n        $c1: false\n      };\n    }\n    else if (r0 == null && c0 != null) {\n      final = {\n        r0: null,\n        c0: c0,\n        r1: null,\n        c1: c0,\n        $r0: false,\n        $c0: $c0,\n        $r1: false,\n        $c1: $c0\n      };\n    }\n    else {\n      final = {\n        r0: r0 || 0,\n        c0: c0 || 0,\n        r1: r0 || 0,\n        c1: c0 || 0,\n        $r0: $r0 || false,\n        $c0: $c0 || false,\n        $r1: $r0 || false,\n        $c1: $c0 || false\n      };\n    }\n  }\n  if (final && trim) {\n    final.trim = trim;\n  }\n  return final;\n}\n","/*\n** RC notation works differently from A1 in that we can't merge static\n** references joined by `:`. Merging can only work between references\n** that are relative/absolute on the same axes, so:\n** - R1C1:R2C2 will work,\n** - R[1]C1:R[2]C2 will also work, but\n** - R[1]C[1]:R2C2 doesn't have a direct rectangle represention without context.\n*/\nimport type { ReferenceName, ReferenceNameXlsx, ReferenceR1C1, ReferenceR1C1Xlsx } from './types.ts';\nimport { parseR1C1Range } from './parseR1C1Range.ts';\nimport { parseRefCtx, parseRefXlsx } from './parseRef.ts';\n\n/**\n * Options for {@link parseR1C1Ref}.\n */\nexport type OptsParseR1C1Ref = {\n  /**\n   * Enable parsing names as well as ranges.\n   * @defaultValue true\n   */\n  allowNamed?: boolean;\n  /**\n   * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.\n   * These are supported by Google Sheets but not Excel.\n   * See: [References.md](./References.md).\n   * @defaultValue false\n   */\n  allowTernary?: boolean;\n};\n\n/**\n * Parse a string reference into an object representing it.\n *\n * ```js\n * parseR1C1Ref('Sheet1!R[9]C9:R[9]C9');\n * // => {\n * //   context: [ 'Sheet1' ],\n * //   range: {\n * //     r0: 9,\n * //     c0: 8,\n * //     r1: 9,\n * //     c1: 8,\n * //     $c0: true,\n * //     $c1: true\n * //     $r0: false,\n * //     $r1: false\n * //   }\n * // }\n * ```\n *\n * @see {@link OptsParseR1C1Ref}\n * @param refString An R1C1-style reference string.\n * @param [options] Options.\n * @returns An object representing a valid reference or `undefined` if it is invalid.\n */\nexport function parseR1C1Ref (\n  refString: string,\n  options: OptsParseR1C1Ref = {}\n): ReferenceR1C1 | ReferenceName | undefined {\n  const {\n    allowNamed = true,\n    allowTernary = false\n  } = options;\n  const d = parseRefCtx(refString, { allowNamed, allowTernary, r1c1: true });\n  if (d) {\n    if (d.name) {\n      return { context: d.context, name: d.name } as ReferenceName;\n    }\n    else if (d.r0) {\n      const range = d.r1\n        ? parseR1C1Range(d.r0 + d.operator + d.r1)\n        : parseR1C1Range(d.r0);\n      if (range) {\n        return { context: d.context, range } as ReferenceR1C1;\n      }\n    }\n  }\n}\n\n/**\n * Parse a string reference into an object representing it.\n *\n * ```js\n * parseR1C1Ref('Sheet1!R[9]C9:R[9]C9');\n * // => {\n * //   context: [ 'Sheet1' ],\n * //   range: {\n * //     r0: 9,\n * //     c0: 8,\n * //     r1: 9,\n * //     c1: 8,\n * //     $c0: true,\n * //     $c1: true\n * //     $r0: false,\n * //     $r1: false\n * //   }\n * // }\n * ```\n *\n * @see {@link OptsParseR1C1Ref}\n * @param refString An R1C1-style reference string.\n * @param [options] Options.\n * @returns An object representing a valid reference or `undefined` if it is invalid.\n */\nexport function parseR1C1RefXlsx (\n  refString: string,\n  options: OptsParseR1C1Ref = {}\n): ReferenceR1C1Xlsx | ReferenceNameXlsx | undefined {\n  const {\n    allowNamed = true,\n    allowTernary = false\n  } = options;\n  const d = parseRefXlsx(refString, { allowNamed, allowTernary, r1c1: true });\n  if (d) {\n    if (d.name && allowNamed) {\n      return { workbookName: d.workbookName, sheetName: d.sheetName, name: d.name } as ReferenceNameXlsx;\n    }\n    else if (d.r0) {\n      const range = d.r1\n        ? parseR1C1Range(d.r0 + d.operator + d.r1)\n        : parseR1C1Range(d.r0);\n      if (range) {\n        return { workbookName: (d).workbookName, sheetName: (d).sheetName, range } as ReferenceR1C1Xlsx;\n      }\n    }\n  }\n}\n","import { MAX_ROWS, MAX_COLS, ERROR } from './constants.ts';\nimport { stringifyA1RefXlsx } from './stringifyA1Ref.ts';\nimport { parseR1C1RefXlsx } from './parseR1C1Ref.ts';\nimport { tokenizeXlsx } from './tokenize.ts';\nimport { isRange } from './isType.ts';\nimport { parseA1Range } from './parseA1Range.ts';\nimport type { RangeA1, ReferenceR1C1Xlsx, Token } from './types.ts';\nimport { stringifyTokens } from './stringifyTokens.ts';\nimport { cloneToken } from './cloneToken.ts';\nimport { OPERATOR } from './constants.ts';\nimport { quotePrefix } from './stringifyPrefix.ts';\n\n// Turn on the most permissive setting when parsing ranges so we don't have to think about\n// this option. We already know that range tokens are legal, so we're not going to encounter\n// ternary ranges who's validity we need to worry about.\nconst REF_OPTS = { allowTernary: true };\n\nfunction toFixed (val: number, abs: boolean, base: number, max: number, wrapEdges = true) {\n  let v = val;\n  if (v != null && !abs) {\n    v = base + val;\n    // Excel \"wraps around\" when value goes out of lower bounds.\n    // It's a bit quirky on entry as Excel _really wants_ to re-rewite the\n    // references but the behaviour is consistent with INDIRECT:\n    // ... In A1: RC[-1] => R1C[16383].\n    if (v < 0) {\n      if (!wrapEdges) {\n        return NaN;\n      }\n      v = max + v + 1;\n    }\n    // ... In B1: =RC[16383] => =RC[-1]\n    if (v > max) {\n      if (!wrapEdges) {\n        return NaN;\n      }\n      v -= max + 1;\n    }\n  }\n  return v;\n}\n\n/**\n * Options for {@link translateTokensToA1}\n */\nexport type OptsTranslateTokensToA1 = {\n  /**\n  * Wrap out-of-bounds ranges around sheet edges rather than turning them to #REF! errors.\n  * @defaultValue true\n  */\n  wrapEdges?: boolean,\n};\n\n/**\n * Translates ranges in a list of tokens from relative R1C1 syntax to absolute A1 syntax.\n *\n * ```js\n * translateToA1(\"=SUM(RC[1],R2C5,Sheet!R3C5)\", \"D10\");\n * // => \"=SUM(E10,$E$2,Sheet!$E$3)\");\n * ```\n *\n * If an input range is -1,-1 relative rows/columns and the anchor is A1, the\n * resulting range will (by default) wrap around to the bottom of the sheet\n * resulting in the range XFD1048576. This may not be what you want so may set\n * `{ wrapEdges }` to false which will instead turn the range into a `#REF!` error.\n *\n * ```js\n * translateToA1(\"=R[-1]C[-1]\", \"A1\");\n * // => \"=XFD1048576\");\n *\n * translateToA1(\"=R[-1]C[-1]\", \"A1\", { wrapEdges: false });\n * // => \"=#REF!\");\n * ```\n *\n * Note that if you are passing in a list of tokens that was not created using\n * `mergeRefs` and you disable edge wrapping (or you simply set both options\n * to false), you can end up with a formula such as `=#REF!:B2` or\n * `=Sheet3!#REF!:F3`. These are valid formulas in the Excel formula language\n * and Excel will accept them, but they are not supported in Google Sheets.\n *\n * @see {@link OptsTranslateTokensToA1}\n * @param tokens A token list that should be adjusted.\n * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).\n * @param options Translation options.\n * @returns A token list.\n */\nexport function translateTokensToA1 (\n  tokens: Token[],\n  anchorCell: string,\n  options: OptsTranslateTokensToA1 = {}\n): Token[] {\n  const anchorRange = parseA1Range(anchorCell);\n  if (!anchorRange) {\n    throw new Error('translateToR1C1 got an invalid anchorCell: ' + anchorCell);\n  }\n  const { top, left } = anchorRange;\n  const { wrapEdges = true } = options;\n\n  let offsetSkew = 0;\n  const outTokens = [];\n  for (let token of tokens) {\n    if (isRange(token)) {\n      token = cloneToken(token);\n      const tokenValue = token.value;\n      // We can get away with using the xlsx ref-parser here because it is more permissive\n      // and we will end up with the same prefix after serialization anyway:\n      const ref = parseR1C1RefXlsx(tokenValue, REF_OPTS) as ReferenceR1C1Xlsx;\n      if (ref) {\n        const d = ref.range;\n        const range: RangeA1 = { top: 0, left: 0 };\n        const r0 = toFixed(d.r0, d.$r0, top, MAX_ROWS, wrapEdges);\n        const r1 = toFixed(d.r1, d.$r1, top, MAX_ROWS, wrapEdges);\n        if (r0 > r1) {\n          range.top = r1;\n          range.$top = d.$r1;\n          range.bottom = r0;\n          range.$bottom = d.$r0;\n        }\n        else {\n          range.top = r0;\n          range.$top = d.$r0;\n          range.bottom = r1;\n          range.$bottom = d.$r1;\n        }\n        const c0 = toFixed(d.c0, d.$c0, left, MAX_COLS, wrapEdges);\n        const c1 = toFixed(d.c1, d.$c1, left, MAX_COLS, wrapEdges);\n        if (c0 > c1) {\n          range.left = c1;\n          range.$left = d.$c1;\n          range.right = c0;\n          range.$right = d.$c0;\n        }\n        else {\n          range.left = c0;\n          range.$left = d.$c0;\n          range.right = c1;\n          range.$right = d.$c1;\n        }\n        if (d.trim) {\n          range.trim = d.trim;\n        }\n        if (isNaN(r0) || isNaN(r1) || isNaN(c0) || isNaN(c1)) {\n          // convert to ref error\n          token.type = ERROR;\n          token.value = '#REF!';\n          delete token.groupId;\n        }\n        else {\n          ref.range = range;\n          // @ts-expect-error -- reusing the object, switching it to A1 by swapping the range\n          token.value = stringifyA1RefXlsx(ref);\n        }\n      }\n      // if token includes offsets, those offsets are now likely wrong!\n      if (token.loc) {\n        token.loc[0] += offsetSkew;\n        offsetSkew += token.value.length - tokenValue.length;\n        token.loc[1] += offsetSkew;\n      }\n    }\n    else if (offsetSkew && token.loc) {\n      token = cloneToken(token);\n      token.loc[0] += offsetSkew;\n      token.loc[1] += offsetSkew;\n    }\n    outTokens[outTokens.length] = token;\n  }\n\n  // Excel unconditionally quotes the sheet prefix on the RHS of a range\n  // operator in XLSX files: Sheet1!A1:Sheet1!B2 → Sheet1!A1:'Sheet1'!B2.\n  // Apply the same quoting to match Excel's serialization.\n  for (let i = 2; i < outTokens.length; i++) {\n    const tok = outTokens[i];\n    if (!isRange(tok)) {\n      continue;\n    }\n    const prev = outTokens[i - 1];\n    if (prev?.type !== OPERATOR || prev.value !== ':') {\n      continue;\n    }\n    const bangIdx = tok.value.indexOf('!');\n    if (bangIdx > 0) {\n      const prefix = tok.value.slice(0, bangIdx);\n      // Only quote if not already quoted\n      if (prefix[0] !== \"'\") {\n        outTokens[i] = cloneToken(tok);\n        outTokens[i].value = quotePrefix(prefix) + tok.value.slice(bangIdx);\n      }\n    }\n  }\n\n  return outTokens;\n}\n\n/**\n * Options for {@link translateFormulaToA1}.\n */\nexport type OptsTranslateFormulaToA1 = {\n  /**\n  * Wrap out-of-bounds ranges around sheet edges rather than turning them to #REF! errors.\n  * @defaultValue true\n  */\n  wrapEdges?: boolean,\n  /**\n  * Should ranges be treated as whole references (`Sheet1!A1:B2`) or as separate tokens\n  * for each part: (`Sheet1`,`!`,`A1`,`:`,`B2`).\n  * @defaultValue true\n  */\n  mergeRefs?: boolean,\n  /**\n  * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.\n  * These are supported by Google Sheets but not Excel. See: References.md.\n  * @defaultValue true\n  */\n  allowTernary?: boolean,\n};\n\n/**\n * Translates ranges in a formula from relative R1C1 syntax to absolute A1 syntax.\n *\n * ```js\n * translateToA1(\"=SUM(RC[1],R2C5,Sheet!R3C5)\", \"D10\");\n * // => \"=SUM(E10,$E$2,Sheet!$E$3)\");\n * ```\n *\n * If an input range is -1,-1 relative rows/columns and the anchor is A1, the\n * resulting range will (by default) wrap around to the bottom of the sheet\n * resulting in the range XFD1048576. This may not be what you want so you can set\n * `{ wrapEdges }` to false which will instead turn the range into a `#REF!` error.\n *\n * ```js\n * translateToA1(\"=R[-1]C[-1]\", \"A1\");\n * // => \"=XFD1048576\");\n *\n * translateToA1(\"=R[-1]C[-1]\", \"A1\", { wrapEdges: false });\n * // => \"=#REF!\");\n * ```\n *\n * @see {@link OptsTranslateFormulaToA1}\n * @param formula An Excel formula string that should be adjusted.\n * @param anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).\n * @param options Translation options.\n * @returns A formula string.\n */\nexport function translateFormulaToA1 (\n  formula: string,\n  anchorCell: string,\n  options: OptsTranslateFormulaToA1 = {}\n): string {\n  if (typeof formula === 'string') {\n    return stringifyTokens(translateTokensToA1(tokenizeXlsx(formula, {\n      allowTernary: options.allowTernary ?? true,\n      mergeRefs: options.mergeRefs,\n      r1c1: true\n    }), anchorCell, options));\n  }\n  throw new Error('translateFormulaToA1 expects a formula string');\n}\n","import { parseRefCtx, parseRefXlsx } from './parseRef.ts';\nimport { parseA1Range } from './parseA1Range.ts';\nimport type { ReferenceA1, ReferenceA1Xlsx, ReferenceName, ReferenceNameXlsx } from './types.ts';\n\n/**\n * Options for {@link parseA1Ref}.\n */\nexport type OptsParseA1Ref = {\n  /**\n   * Enable parsing names as well as ranges.\n   * @defaultValue true\n   */\n  allowNamed?: boolean,\n  /**\n   * Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`.\n   * These are supported by Google Sheets but not Excel. See: [References.md](./References.md).\n   * @defaultValue false\n   */\n  allowTernary?: boolean,\n};\n\n/**\n * Parse a string reference into an object representing it.\n *\n * ```js\n * parseA1Ref('Sheet1!A$1:$B2');\n * // => {\n * //   context: [ 'Sheet1' ],\n * //   range: {\n * //     top: 0,\n * //     left: 0,\n * //     bottom: 1,\n * //     right: 1\n * //     $top: true,\n * //     $left: false,\n * //     $bottom: false,\n * //     $right: true\n * //   }\n * // }\n * ```\n *\n * For A:A or A1:A style ranges, `null` will be used for any dimensions that the\n * syntax does not specify.\n *\n * @see {@link OptsParseA1Ref}\n * @param refString An A1-style reference string.\n * @param options Options.\n * @returns An object representing a valid reference or `undefined` if it is invalid.\n */\nexport function parseA1Ref (\n  refString: string,\n  { allowNamed = true, allowTernary = false }: OptsParseA1Ref = {}\n): ReferenceA1 | ReferenceName | undefined {\n  const d = parseRefCtx(refString, { allowNamed, allowTernary, r1c1: false });\n  if (d) {\n    if (d.name) {\n      return { context: d.context, name: d.name };\n    }\n    else if (d.r0) {\n      const range = parseA1Range(d.r1 ? d.r0 + d.operator + d.r1 : d.r0);\n      if (range) {\n        return { context: d.context, range };\n      }\n    }\n  }\n}\n\n/**\n * Parse a string reference into an object representing it.\n *\n * ```js\n * parseA1Ref('Sheet1!A$1:$B2');\n * // => {\n * //   workbookName: '',\n * //   sheetName: 'Sheet1',\n * //   range: {\n * //     top: 0,\n * //     left: 0,\n * //     bottom: 1,\n * //     right: 1\n * //     $top: true,\n * //     $left: false,\n * //     $bottom: false,\n * //     $right: true\n * //   }\n * // }\n * ```\n *\n * For A:A or A1:A style ranges, `null` will be used for any dimensions that the\n * syntax does not specify.\n *\n * @see {@link OptsParseA1Ref}\n * @param refString An A1-style reference string.\n * @param options Options.\n * @returns An object representing a valid reference or `undefined` if it is invalid.\n */\nexport function parseA1RefXlsx (\n  refString: string,\n  { allowNamed = true, allowTernary = false }: OptsParseA1Ref = {}\n): ReferenceA1Xlsx | ReferenceNameXlsx | undefined {\n  const d = parseRefXlsx(refString, { allowNamed, allowTernary, r1c1: false });\n  if (d) {\n    if (d.name) {\n      return { workbookName: d.workbookName, sheetName: d.sheetName, name: d.name };\n    }\n    else if (d.r0) {\n      if (d.r0) {\n        const range = parseA1Range(d.r1 ? d.r0 + d.operator + d.r1 : d.r0);\n        if (range) {\n          return { workbookName: d.workbookName, sheetName: d.sheetName, range };\n        }\n      }\n    }\n  }\n}\n","import { MAX_ROWS, MAX_COLS } from './constants.ts';\nimport type { RangeA1 } from './types.ts';\n\n/**\n * Fill the any missing bounds in range objects. Top will be set to 0, bottom to\n * 1048575, left to 0, and right to 16383, if they are `null` or `undefined`.\n *\n * ```js\n * addA1RangeBounds({\n *   top: 0,\n *   left: 0,\n *   bottom: 1,\n *   $top: true,\n *   $left: false,\n *   $bottom: false,\n * });\n * // => {\n * //   top: 0,\n * //   left: 0,\n * //   bottom: 1,\n * //   right: 16383,  // ← Added\n * //   $top: true,\n * //   $left: false,\n * //   $bottom: false,\n * //   $right: false  // ← Added\n * // }\n * ```\n *\n * @param range The range part of a reference object.\n * @returns The same range with missing bounds filled in.\n */\nexport function addA1RangeBounds (range: RangeA1): RangeA1 {\n  if (range.top == null) {\n    range.top = 0;\n    range.$top = false;\n  }\n  if (range.bottom == null) {\n    range.bottom = MAX_ROWS;\n    range.$bottom = false;\n  }\n  if (range.left == null) {\n    range.left = 0;\n    range.$left = false;\n  }\n  if (range.right == null) {\n    range.right = MAX_COLS;\n    range.$right = false;\n  }\n  return range;\n}\n","import type { ReferenceStruct, ReferenceStructXlsx } from './types.ts';\nimport { parseRefCtx, parseRefXlsx } from './parseRef.ts';\nimport { parseSRange } from './parseSRange.ts';\n\n/**\n * Parse a structured reference string into an object representing it.\n *\n * ```js\n * parseStructRef('workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]');\n * // => {\n * //   context: [ 'workbook.xlsx' ],\n * //   sections: [ 'data' ],\n * //   columns: [ 'my column', '@foo' ],\n * //   table: 'tableName',\n * // }\n * ```\n *\n * For A:A or A1:A style ranges, `null` will be used for any dimensions that the\n * syntax does not specify:\n *\n * See [References.md](./References.md).\n *\n * @param ref A structured reference string\n * @returns An object representing a valid reference or `undefined` if it is invalid.\n */\nexport function parseStructRef (ref: string): ReferenceStruct | undefined {\n  const r = parseRefCtx(ref);\n  if (r && r.struct) {\n    const structData = parseSRange(r.struct);\n    if (structData && structData.length === r.struct.length) {\n      return {\n        context: r.context,\n        table: r.name,\n        columns: structData.columns,\n        sections: structData.sections\n      };\n    }\n  }\n}\n\n/**\n * Parse a structured reference string into an object representing it.\n *\n * ```js\n * parseStructRef('[workbook.xlsx]!tableName[[#Data],[Column1]:[Column2]]');\n * // => {\n * //   workbookName: 'workbook.xlsx',\n * //   sections: [ 'data' ],\n * //   columns: [ 'my column', '@foo' ],\n * //   table: 'tableName',\n * // }\n * ```\n *\n * For A:A or A1:A style ranges, `null` will be used for any dimensions that the\n * syntax does not specify:\n *\n * See [References.md](./References.md).\n *\n * @param ref A structured reference string\n * @returns An object representing a valid reference or null if it is invalid.\n */\nexport function parseStructRefXlsx (ref: string): ReferenceStructXlsx | undefined {\n  const r = parseRefXlsx(ref);\n  if (r && r.struct) {\n    const structData = parseSRange(r.struct);\n    if (structData && structData.length === r.struct.length) {\n      return {\n        workbookName: r.workbookName,\n        sheetName: r.sheetName,\n        table: r.name,\n        columns: structData.columns,\n        sections: structData.sections\n      };\n    }\n  }\n}\n","import type { ReferenceStruct, ReferenceStructXlsx } from './types.ts';\nimport { stringifyPrefix, stringifyPrefixXlsx } from './stringifyPrefix.ts';\n\nfunction quoteColname (str: string): string {\n  return str.replace(/([[\\]#'@])/g, '\\'$1');\n}\n\nfunction needsBraces (str: string): boolean {\n  return /[^a-zA-Z0-9\\u00a1-\\uffff]/.test(str);\n}\n\nfunction toSentenceCase (str: string): string {\n  return str[0].toUpperCase() + str.slice(1).toLowerCase();\n}\n\nexport function stringifySRef (refObject: ReferenceStruct, thisRow = false) {\n  let s = '';\n  if (refObject.table) {\n    s += refObject.table;\n  }\n  const numColumns = refObject.columns?.length ?? 0;\n  const numSections = refObject.sections?.length ?? 0;\n  // single section\n  if (numSections === 1 && !numColumns) {\n    s += `[#${toSentenceCase(refObject.sections[0])}]`;\n  }\n  // single column\n  else if (!numSections && numColumns === 1) {\n    s += `[${quoteColname(refObject.columns[0])}]`;\n  }\n  else {\n    s += '[';\n    // single [#this row] sections get normalized to an @ by default\n    const singleAt = !thisRow && numSections === 1 && refObject.sections[0].toLowerCase() === 'this row';\n    if (singleAt) {\n      s += '@';\n    }\n    else if (numSections) {\n      s += refObject.sections\n        .map(d => `[#${toSentenceCase(d)}]`)\n        .join(',');\n      if (numColumns) {\n        s += ',';\n      }\n    }\n    // a case of a single alphanumberic column with a [#this row] becomes [@col]\n    if (singleAt && refObject.columns.length === 1 && !needsBraces(refObject.columns[0])) {\n      s += quoteColname(refObject.columns[0]);\n    }\n    else if (numColumns) {\n      s += refObject.columns.slice(0, 2)\n        .map(d => (`[${quoteColname(d)}]`))\n        .join(':');\n    }\n    s += ']';\n  }\n  return s;\n}\n\n/**\n * Options for {@link stringifyStructRef}\n */\nexport type OptsStringifyStructRef = {\n  /**\n   * Enforces using the `[#This Row]` instead of the `@` shorthand when serializing structured ranges.\n   * @defaultValue false\n   */\n  thisRow?: boolean;\n};\n\n/**\n * Returns a string representation of a structured reference object.\n *\n * ```js\n * stringifyStructRef({\n *   context: [ 'workbook.xlsx' ],\n *   sections: [ 'data' ],\n *   columns: [ 'my column', '@foo' ],\n *   table: 'tableName',\n * });\n * // => 'workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]'\n * ```\n *\n * @see {@link OptsStringifyStructRef}\n * @param refObject A structured reference object.\n * @param [options={}] Options.\n * @returns The given structured reference in string format.\n */\nexport function stringifyStructRef (refObject: ReferenceStruct, options: OptsStringifyStructRef = {}): string {\n  return stringifyPrefix(refObject) + stringifySRef(refObject, !!options.thisRow);\n}\n\n/**\n * Returns a string representation of a structured reference object.\n *\n * ```js\n * stringifyStructRef({\n *   workbookName: 'workbook.xlsx',\n *   sheetName: '',\n *   sections: [ 'data' ],\n *   columns: [ 'my column', '@foo' ],\n *   table: 'tableName',\n * });\n * // => 'workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]'\n * ```\n *\n * @param refObject A structured reference object.\n * @param [options] Options.\n * @returns The given structured reference in string format.\n */\nexport function stringifyStructRefXlsx (refObject: ReferenceStructXlsx, options: OptsStringifyStructRef = {}): string {\n  return stringifyPrefixXlsx(refObject) + stringifySRef(refObject, !!options.thisRow);\n}\n","import { isRange } from './isType.ts';\nimport { parseA1Ref, parseA1RefXlsx } from './parseA1Ref.ts';\nimport { stringifyA1Ref, stringifyA1RefXlsx } from './stringifyA1Ref.ts';\nimport { addA1RangeBounds } from './addA1RangeBounds.ts';\nimport { parseStructRef, parseStructRefXlsx } from './parseStructRef.ts';\nimport { stringifyStructRef, stringifyStructRefXlsx } from './stringifyStructRef.ts';\nimport { tokenize, type OptsTokenize, tokenizeXlsx } from './tokenize.ts';\nimport { REF_STRUCT } from './constants.ts';\nimport type { ReferenceA1, ReferenceA1Xlsx, Token } from './types.ts';\nimport { cloneToken } from './cloneToken.ts';\nimport { stringifyTokens } from './stringifyTokens.ts';\n\n// There is no R1C1 counterpart to this. This is because without an anchor cell\n// it is impossible to determine if a relative+absolute range (R[1]C[1]:R5C5)\n// needs to be flipped or not. The solution is to convert to A1 first:\n// translateToRC(fixRanges(translateToA1(...)))\n\n/**\n * Options for {@link fixTokenRanges} and {@link fixFormulaRanges}.\n */\nexport type OptsFixRanges = {\n  /**\n   * Fill in any undefined bounds of range objects. Top to 0, bottom to 1048575, left to 0, and right to 16383.\n   * @defaultValue false\n   */\n  addBounds?: boolean,\n  /**\n   * Enforces using the `[#This Row]` instead of the `@` shorthand when serializing structured ranges.\n   * @defaultValue false\n   */\n  thisRow?: boolean,\n};\n\n/**\n * Normalizes A1 style ranges and structured references in a list of tokens.\n *\n * It ensures that that the top and left coordinates of an A1 range are on the\n * left-hand side of a colon operator:\n *\n * ```\n * B2:A1 → A1:B2\n * 1:A1 → A1:1\n * A:A1 → A1:A\n * B:A → A:B\n * 2:1 → 1:2\n * A1:A1 → A1\n * ```\n *\n * When `{ addBounds }` option is set to true, the missing bounds are also added.\n * This can be done to ensure Excel compatible ranges. The fixes then additionally include:\n *\n * ```\n * 1:A1 → A1:1 → 1:1\n * A:A1 → A1:A → A:A\n * A1:A → A:A\n * A1:1 → A:1\n * B2:B → B2:1048576\n * B2:2 → B2:XFD2\n * ```\n *\n * Structured ranges are normalized to have consistent order and capitalization\n * of sections as well as removing redundant ones.\n *\n * Returns a new array of tokens with values and position data updated.\n *\n * @see {@link OptsFixRanges}\n * @param tokens A list of tokens to be adjusted.\n * @param [options]  Options.\n * @returns A token list with ranges adjusted.\n */\nexport function fixTokenRanges (\n  tokens: Token[],\n  options: OptsFixRanges = {}\n): Token[] {\n  if (!Array.isArray(tokens)) {\n    throw new Error('fixRanges expects an array of tokens');\n  }\n  const { addBounds, thisRow } = options;\n  let offsetSkew = 0;\n  const output: Token[] = [];\n  for (const t of tokens) {\n    const token = cloneToken(t);\n    let offsetDelta = 0;\n    if (token.type === REF_STRUCT) {\n      const sref = parseStructRef(token.value);\n      const newValue = stringifyStructRef(sref, { thisRow });\n      offsetDelta = newValue.length - token.value.length;\n      token.value = newValue;\n    }\n    else if (isRange(token)) {\n      const ref = parseA1Ref(token.value, { allowTernary: true }) as ReferenceA1;\n      const range = ref.range;\n      // fill missing dimensions?\n      if (addBounds) {\n        addA1RangeBounds(range);\n      }\n      const newValue = stringifyA1Ref(ref);\n      offsetDelta = newValue.length - token.value.length;\n      token.value = newValue;\n    }\n    // ensure that positioning is still correct\n    if (offsetSkew || offsetDelta) {\n      if (token.loc) {\n        token.loc[0] += offsetSkew;\n      }\n      offsetSkew += offsetDelta;\n      if (token.loc) {\n        token.loc[1] += offsetSkew;\n      }\n    }\n    else {\n      offsetSkew += offsetDelta;\n    }\n    output.push(token);\n  }\n\n  return output;\n}\n\n/**\n * Normalizes A1 style ranges and structured references in a list of tokens.\n *\n * It ensures that that the top and left coordinates of an A1 range are on the\n * left-hand side of a colon operator:\n *\n * ```\n * B2:A1 → A1:B2\n * 1:A1 → A1:1\n * A:A1 → A1:A\n * B:A → A:B\n * 2:1 → 1:2\n * A1:A1 → A1\n * ```\n *\n * When `{ addBounds }` option is set to true, the missing bounds are also added.\n * This can be done to ensure Excel compatible ranges. The fixes then additionally include:\n *\n * ```\n * 1:A1 → A1:1 → 1:1\n * A:A1 → A1:A → A:A\n * A1:A → A:A\n * A1:1 → A:1\n * B2:B → B2:1048576\n * B2:2 → B2:XFD2\n * ```\n *\n * Structured ranges are normalized to have consistent order and capitalization\n * of sections as well as removing redundant ones.\n *\n * Returns a new array of tokens with values and position data updated.\n *\n * @see {@link OptsFixRanges}\n * @param tokens A list of tokens to be adjusted.\n * @param [options]  Options.\n * @returns A token list with ranges adjusted.\n */\nexport function fixTokenRangesXlsx (\n  tokens: Token[],\n  options: OptsFixRanges = {}\n): Token[] {\n  if (!Array.isArray(tokens)) {\n    throw new Error('fixRanges expects an array of tokens');\n  }\n  const { addBounds, thisRow } = options;\n  let offsetSkew = 0;\n  const output: Token[] = [];\n  for (const t of tokens) {\n    const token = cloneToken(t);\n    let offsetDelta = 0;\n    if (token.type === REF_STRUCT) {\n      const sref = parseStructRefXlsx(token.value);\n      const newValue = stringifyStructRefXlsx(sref, { thisRow });\n      offsetDelta = newValue.length - token.value.length;\n      token.value = newValue;\n    }\n    else if (isRange(token)) {\n      const ref = parseA1RefXlsx(token.value, { allowTernary: true }) as ReferenceA1Xlsx;\n      const range = ref.range;\n      // fill missing dimensions?\n      if (addBounds) {\n        addA1RangeBounds(range);\n      }\n      const newValue = stringifyA1RefXlsx(ref);\n      offsetDelta = newValue.length - token.value.length;\n      token.value = newValue;\n    }\n    // ensure that positioning is still correct\n    if (offsetSkew || offsetDelta) {\n      if (token.loc) {\n        token.loc[0] += offsetSkew;\n      }\n      offsetSkew += offsetDelta;\n      if (token.loc) {\n        token.loc[1] += offsetSkew;\n      }\n    }\n    else {\n      offsetSkew += offsetDelta;\n    }\n    output.push(token);\n  }\n\n  return output;\n}\n\n/**\n * Normalizes A1 style ranges and structured references in a formula.\n *\n * Internally it uses {@link fixTokenRanges} so see it's documentation for details.\n *\n * Returns the same formula with the ranges updated. If an array of tokens was\n * supplied, then a new array is returned.\n *\n * @see {@link OptsFixRanges} & {@link OptsTokenize}\n * @param formula A string (an Excel formula) or a token list that should be adjusted.\n * @param [options]  Options\n * @returns A formula string with ranges adjusted\n */\nexport function fixFormulaRanges (\n  formula: string,\n  options: OptsFixRanges & OptsTokenize = {}\n): string {\n  if (typeof formula !== 'string') {\n    throw new Error('fixFormulaRanges expects a string formula');\n  }\n  return stringifyTokens(\n    fixTokenRanges(\n      tokenize(formula, options),\n      options\n    )\n  );\n}\n\n/**\n * Normalizes A1 style ranges and structured references in a formula.\n *\n * Internally it uses {@link fixTokenRanges} so see it's documentation for details.\n *\n * Returns the same formula with the ranges updated. If an array of tokens was\n * supplied, then a new array is returned.\n *\n * @see {@link OptsFixRanges} & {@link OptsTokenize}\n * @param formula A string (an Excel formula) or a token list that should be adjusted.\n * @param [options]  Options\n * @returns A formula string with ranges adjusted\n */\nexport function fixFormulaRangesXlsx (\n  formula: string,\n  options: OptsFixRanges & OptsTokenize = {}\n): string {\n  if (typeof formula !== 'string') {\n    throw new Error('fixFormulaRanges expects a string formula');\n  }\n  return stringifyTokens(\n    fixTokenRangesXlsx(\n      tokenizeXlsx(formula, options),\n      options\n    )\n  );\n}\n","import type {\n  Node,\n  Identifier,\n  ReferenceIdentifier,\n  Literal,\n  ErrorLiteral,\n  UnaryExpression,\n  BinaryExpression,\n  CallExpression,\n  ArrayExpression,\n  LambdaExpression,\n  LetExpression,\n  LetDeclarator,\n  AstExpression\n} from './astTypes.ts';\nimport {\n  ARRAY,\n  BINARY,\n  CALL,\n  ERROR_LITERAL,\n  IDENTIFIER,\n  LAMBDA,\n  LET,\n  LET_DECL,\n  LITERAL,\n  REFERENCE,\n  UNARY\n} from './constants.ts';\n\n/**\n * Determines whether the specified node is an Identifier.\n * @param node An AST node.\n * @returns True if the specified token is an Identifier, False otherwise.\n */\nexport function isIdentifierNode (node?: Node | null): node is Identifier {\n  return node?.type === IDENTIFIER;\n}\n\n/**\n * Determines whether the specified node is a ReferenceIdentifier.\n * @param node An AST node.\n * @returns True if the specified token is a ReferenceIdentifier, False otherwise.\n */\nexport function isReferenceNode (node?: Node | null): node is ReferenceIdentifier {\n  return node?.type === REFERENCE;\n}\n\n/**\n * Determines whether the specified node is a Literal.\n * @param node An AST node.\n * @returns True if the specified token is a Literal, False otherwise.\n */\nexport function isLiteralNode (node?: Node | null): node is Literal {\n  return node?.type === LITERAL;\n}\n\n/**\n * Determines whether the specified node is an ErrorLiteral.\n * @param node An AST node.\n * @returns True if the specified token is an ErrorLiteral, False otherwise.\n */\nexport function isErrorNode (node?: Node | null): node is ErrorLiteral {\n  return node?.type === ERROR_LITERAL;\n}\n\n/**\n * Determines whether the specified node is a UnaryExpression.\n * @param node An AST node.\n * @returns True if the specified token is a UnaryExpression, False otherwise.\n */\nexport function isUnaryNode (node?: Node | null): node is UnaryExpression {\n  return node?.type === UNARY;\n}\n\n/**\n * Determines whether the specified node is a BinaryExpression.\n * @param node An AST node.\n * @returns True if the specified token is a BinaryExpression, False otherwise.\n */\nexport function isBinaryNode (node?: Node | null): node is BinaryExpression {\n  return node?.type === BINARY;\n}\n\n/**\n * Determines whether the specified node is a CallExpression.\n * @param node An AST node.\n * @returns True if the specified token is a CallExpression, False otherwise.\n */\nexport function isCallNode (node?: Node | null): node is CallExpression {\n  return node?.type === CALL;\n}\n\n/**\n * Determines whether the specified node is a ArrayExpression.\n * @param node An AST node.\n * @returns True if the specified token is a ArrayExpression, False otherwise.\n */\nexport function isArrayNode (node?: Node | null): node is ArrayExpression {\n  return node?.type === ARRAY;\n}\n\n/**\n * Determines whether the specified node is a LambdaExpression.\n * @param node An AST node.\n * @returns True if the specified token is a LambdaExpression, False otherwise.\n */\nexport function isLambdaNode (node?: Node | null): node is LambdaExpression {\n  return node?.type === LAMBDA;\n}\n\n/**\n * Determines whether the specified node is a LetExpression.\n * @param node An AST node.\n * @returns True if the specified token is a LetExpression, False otherwise.\n */\nexport function isLetNode (node?: Node | null): node is LetExpression {\n  return node?.type === LET;\n}\n\n/**\n * Determines whether the specified node is a LetDeclarator.\n * @param node An AST node.\n * @returns True if the specified token is a LetDeclarator, False otherwise.\n */\nexport function isLetDeclaratorNode (node?: Node | null): node is LetDeclarator {\n  return node?.type === LET_DECL;\n}\n\n/**\n * Determines whether the specified node is a AstExpression.\n * @param node An AST node.\n * @returns True if the specified token is a AstExpression, False otherwise.\n */\nexport function isExpressionNode (node?: Node | null): node is AstExpression {\n  const type = node?.type;\n  if (type) {\n    return (\n      type === REFERENCE ||\n      type === LITERAL ||\n      type === ERROR_LITERAL ||\n      type === UNARY ||\n      type === BINARY ||\n      type === CALL ||\n      type === ARRAY ||\n      type === LAMBDA ||\n      type === LET\n    );\n  }\n  return false;\n}\n","/**\n * Convert a column string representation to a 0 based\n * offset number (`\"C\"` = `2`).\n *\n * The method expects a valid column identifier made up of _only_\n * A-Z letters, which may be either upper or lower case. Other input will\n * return garbage.\n *\n * @param {string} columnString  The column string identifier\n * @returns {number}  Zero based column index number\n */\nexport function fromCol (columnString: string): number {\n  const x = (columnString || '');\n  const l = x.length;\n  let n = 0;\n  if (l > 2) {\n    const c = x.charCodeAt(l - 3);\n    const a = c > 95 ? 32 : 0;\n    n += (1 + c - a - 65) * 676;\n  }\n  if (l > 1) {\n    const c = x.charCodeAt(l - 2);\n    const a = c > 95 ? 32 : 0;\n    n += (1 + c - a - 65) * 26;\n  }\n  if (l) {\n    const c = x.charCodeAt(l - 1);\n    const a = c > 95 ? 32 : 0;\n    n += (c - a) - 65;\n  }\n  return n;\n}\n","import {\n  OPERATOR,\n  BOOLEAN,\n  ERROR,\n  NUMBER,\n  FUNCTION,\n  NEWLINE,\n  WHITESPACE,\n  STRING,\n  CONTEXT,\n  CONTEXT_QUOTE,\n  REF_RANGE,\n  REF_BEAM,\n  REF_TERNARY,\n  REF_NAMED,\n  REF_STRUCT,\n  FX_PREFIX,\n  UNKNOWN\n} from './constants.ts';\n\n/**\n * A dictionary of the types used to identify token variants.\n * @prop OPERATOR - Unary or binary operator (`+`, `%`)\n * @prop BOOLEAN - Boolean literal (`TRUE`)\n * @prop ERROR - Error literal (`#VALUE!`)\n * @prop NUMBER - Number literal (`123.4`, `-1.5e+2`)\n * @prop FUNCTION - Function name (`SUM`)\n * @prop NEWLINE - Newline character (`\\n`)\n * @prop WHITESPACE - Whitespace character sequence (` `)\n * @prop STRING - String literal (`\"Lorem ipsum\"`)\n * @prop CONTEXT - Reference context ([Workbook.xlsx]Sheet1)\n * @prop CONTEXT_QUOTE - Quoted reference context (`'[My workbook.xlsx]Sheet1'`)\n * @prop REF_RANGE - A range identifier (`A1`)\n * @prop REF_BEAM - A range \"beam\" identifier (`A:A` or `1:1`)\n * @prop REF_TERNARY - A ternary range identifier (`B2:B`)\n * @prop REF_NAMED - A name / named range identifier (`income`)\n * @prop REF_STRUCT - A structured reference identifier (`table[[Column1]:[Column2]]`)\n * @prop FX_PREFIX - A leading equals sign at the start of a formula (`=`)\n * @prop UNKNOWN - Any unidentifiable range of characters.\n */\nexport const tokenTypes = Object.freeze({\n  /** Unary or binary operator (`+`, `%`) */\n  OPERATOR: OPERATOR,\n  /** Boolean literal (`TRUE`) */\n  BOOLEAN: BOOLEAN,\n  /** Error literal (`#VALUE!`) */\n  ERROR: ERROR,\n  /** Number literal (`123.4`, `-1.5e+2`) */\n  NUMBER: NUMBER,\n  /** Function name (`SUM`) */\n  FUNCTION: FUNCTION,\n  /** Newline character (`\\n`) */\n  NEWLINE: NEWLINE,\n  /** Whitespace character sequence (` `) */\n  WHITESPACE: WHITESPACE,\n  /** String literal (`\"Lorem ipsum\"`) */\n  STRING: STRING,\n  /** Reference context ([Workbook.xlsx]Sheet1) */\n  CONTEXT: CONTEXT,\n  /** Quoted reference context (`'[My workbook.xlsx]Sheet1'`) */\n  CONTEXT_QUOTE: CONTEXT_QUOTE,\n  /** A range identifier (`A1`) */\n  REF_RANGE: REF_RANGE,\n  /** A range \"beam\" identifier (`A:A` or `1:1`) */\n  REF_BEAM: REF_BEAM,\n  /** A ternary range identifier (`B2:B`) */\n  REF_TERNARY: REF_TERNARY,\n  /** A name / named range identifier (`income`) */\n  REF_NAMED: REF_NAMED,\n  /** A structured reference identifier (`table[[Column1]:[Column2]]`) */\n  REF_STRUCT: REF_STRUCT,\n  /** A leading equals sign at the start of a formula (`=`) */\n  FX_PREFIX: FX_PREFIX,\n  /** Any unidentifiable range of characters. */\n  UNKNOWN: UNKNOWN\n});\n","import {\n  // AST types\n  UNARY,\n  BINARY,\n  REFERENCE,\n  LITERAL,\n  ERROR_LITERAL,\n  CALL,\n  ARRAY,\n  IDENTIFIER,\n  LAMBDA,\n  LET,\n  LET_DECL\n} from './constants.ts';\n\n/**\n * A dictionary of the types used to identify AST node variants.\n *\n * @prop UNARY - A unary operation (`10%`)\n * @prop BINARY - A binary operation (`10+10`)\n * @prop REFERENCE - A range identifier (`A1`)\n * @prop LITERAL - A literal (number, string, or boolean) (`123`, `\"foo\"`, `false`)\n * @prop ERROR - An error literal (`#VALUE!`)\n * @prop CALL - A function call expression (`SUM(1,2)`)\n * @prop ARRAY - An array expression (`{1,2;3,4}`)\n * @prop IDENTIFIER - A function name identifier (`SUM`)\n * @prop LAMBDA - A LAMBDA expression (`LAMBDA(x,y,x*y)``)\n * @prop LET - A LET expression (`LET(a,A1*10,b,SUM(F:F),a*b)`)\n * @prop LET_DECL - A LET declaration (LET(`a,A1*10`...)\n */\nexport const nodeTypes = Object.freeze({\n  /** A unary operation (`10%`) */\n  UNARY,\n  /** A binary operation (`10+10`) */\n  BINARY,\n  /** A range identifier (`A1`) */\n  REFERENCE,\n  /** A literal (number, string, or boolean) (`123`, `\"foo\"`, `false`) */\n  LITERAL,\n  /** An error literal (`#VALUE!`) */\n  ERROR: ERROR_LITERAL,\n  /** A function call expression (`SUM(1,2)`) */\n  CALL,\n  /** An array expression (`{1,2;3,4}`) */\n  ARRAY,\n  /** A function name identifier (`SUM`) */\n  IDENTIFIER,\n  /** A LAMBDA expression (`LAMBDA(x,y,x*y)``) */\n  LAMBDA,\n  /** A LET expression (`LET(a,A1*10,b,SUM(F:F),a*b)`) */\n  LET,\n  /** A LET declaration (LET(`a,A1*10`...)*/\n  LET_DECL\n});\n"],"mappings":"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","names":["isReferenceNode","tokens","PERIOD","COLON","BR_OPEN","BR_CLOSE","EXCL","c","BR_CLOSE","BR_OPEN","COLON","HASH","QUOT_SINGLE","EXCL","EXCL","BR_OPEN","EXCL","a","tokens","END","FUNCTION","WHITESPACE","prefix","prefix","advRangeOp","advA1Col","advA1Row","tokens","tokens","parse","reLetLambda","unquote","tokens","clamp","prefix","tokens","prefix","tokens","isReferenceNode"]}