@gridsheet/react-core 1.4.0-alpha.2 → 1.4.0-alpha.3

package/dist/formula/functions/vlookup.js

@@ -0,0 +1,75 @@
+import { FormulaError } from "../evaluator.js";
+import { solveTable } from "../solver.js";
+import { Table } from "../../lib/table.js";
+import { BaseFunction } from "./__base.js";
+import { stripTable, ensureNumber, ensureBoolean } from "./__utils.js";
+class VlookupFunction extends BaseFunction {
+  constructor() {
+    super(...arguments);
+    this.example = "VLOOKUP(10003, A2:B26, 2, FALSE)";
+    this.helpText = [
+      "Searches vertically for the specified key in the first column of the range and returns the value of the specified cell in the same row."
+    ];
+    this.helpArgs = [
+      { name: "key", description: "Search key." },
+      {
+        name: "range",
+        description: "A range for search"
+      },
+      {
+        name: "index",
+        description: "The index of the column in the range."
+      },
+      {
+        name: "is_sorted",
+        description: "FALSE: Exact match. This is recommended. TRUE: Approximate match. Before you use an approximate match, sort your search key in ascending order. Otherwise, you may likely get a wrong return value.",
+        option: true
+      }
+    ];
+  }
+  validate() {
+    if (this.bareArgs.length !== 3 && this.bareArgs.length !== 4) {
+      throw new FormulaError("#N/A", "Number of arguments for VLOOKUP is incorrect.");
+    }
+    if (this.bareArgs[0] instanceof Table) {
+      this.bareArgs[0] = stripTable(this.bareArgs[0]);
+    }
+    if (!(this.bareArgs[1] instanceof Table)) {
+      throw new FormulaError("#REF!", "2nd argument must be range");
+    }
+    this.bareArgs[2] = ensureNumber(this.bareArgs[2]);
+    this.bareArgs[3] = ensureBoolean(this.bareArgs[3], true);
+  }
+  main(key, range, index, isSorted) {
+    var _a, _b, _c, _d;
+    const matrix = solveTable({ table: range });
+    if (isSorted) {
+      let last = -1;
+      for (let y = 0; y <= range.getNumRows(); y++) {
+        const v = (_a = matrix[y]) == null ? void 0 : _a[0];
+        if (v == null) {
+          continue;
+        }
+        if (v <= key) {
+          last = y;
+        } else {
+          break;
+        }
+      }
+      if (last !== -1) {
+        return (_b = matrix[last]) == null ? void 0 : _b[index - 1];
+      }
+    } else {
+      for (let y = 0; y <= range.getNumRows(); y++) {
+        if (((_c = matrix[y]) == null ? void 0 : _c[0]) === key) {
+          return (_d = matrix[y]) == null ? void 0 : _d[index - 1];
+        }
+      }
+    }
+    throw new FormulaError("#N/A", `No values found for '${key}'.`);
+  }
+}
+export {
+  VlookupFunction
+};
+//# sourceMappingURL=vlookup.js.map

package/dist/formula/functions/vlookup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vlookup.js","sources":["../../../formula/functions/vlookup.ts"],"sourcesContent":["import { FormulaError } from '../evaluator';\nimport { solveTable } from '../solver';\nimport { Table } from '../../lib/table';\nimport { BaseFunction } from './__base';\nimport { ensureBoolean, ensureNumber, stripTable } from './__utils';\n\nexport class VlookupFunction extends BaseFunction {\n  example = 'VLOOKUP(10003, A2:B26, 2, FALSE)';\n  helpText = [\n    'Searches vertically for the specified key in the first column of the range and returns the value of the specified cell in the same row.',\n  ];\n  helpArgs = [\n    { name: 'key', description: 'Search key.' },\n    {\n      name: 'range',\n      description: 'A range for search',\n    },\n    {\n      name: 'index',\n      description: 'The index of the column in the range.',\n    },\n    {\n      name: 'is_sorted',\n      description:\n        'FALSE: Exact match. This is recommended. TRUE: Approximate match. Before you use an approximate match, sort your search key in ascending order. Otherwise, you may likely get a wrong return value.',\n      option: true,\n    },\n  ];\n\n  protected validate() {\n    if (this.bareArgs.length !== 3 && this.bareArgs.length !== 4) {\n      throw new FormulaError('#N/A', 'Number of arguments for VLOOKUP is incorrect.');\n    }\n    if (this.bareArgs[0] instanceof Table) {\n      this.bareArgs[0] = stripTable(this.bareArgs[0]);\n    }\n    if (!(this.bareArgs[1] instanceof Table)) {\n      throw new FormulaError('#REF!', '2nd argument must be range');\n    }\n    this.bareArgs[2] = ensureNumber(this.bareArgs[2]);\n    this.bareArgs[3] = ensureBoolean(this.bareArgs[3], true);\n  }\n\n  protected main(key: any, range: Table, index: number, isSorted: boolean) {\n    const matrix = solveTable({ table: range });\n    if (isSorted) {\n      let last = -1;\n      for (let y = 0; y <= range.getNumRows(); y++) {\n        const v = matrix[y]?.[0];\n        if (v == null) {\n          continue;\n        }\n        if (v <= key) {\n          last = y;\n        } else {\n          break;\n        }\n      }\n      if (last !== -1) {\n        return matrix[last]?.[index - 1];\n      }\n    } else {\n      for (let y = 0; y <= range.getNumRows(); y++) {\n        if (matrix[y]?.[0] === key) {\n          return matrix[y]?.[index - 1];\n        }\n      }\n    }\n    throw new FormulaError('#N/A', `No values found for '${key}'.`);\n  }\n}\n"],"names":[],"mappings":";;;;;AAMO,MAAM,wBAAwB,aAAa;AAAA,EAA3C,cAAA;AAAA,UAAA,GAAA,SAAA;AACK,SAAA,UAAA;AACC,SAAA,WAAA;AAAA,MACT;AAAA,IACF;AACW,SAAA,WAAA;AAAA,MACT,EAAE,MAAM,OAAO,aAAa,cAAc;AAAA,MAC1C;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA;AAAA,QACE,MAAM;AAAA,QACN,aACE;AAAA,QACF,QAAQ;AAAA,MAAA;AAAA,IAEZ;AAAA,EAAA;AAAA,EAEU,WAAW;AACnB,QAAI,KAAK,SAAS,WAAW,KAAK,KAAK,SAAS,WAAW,GAAG;AACtD,YAAA,IAAI,aAAa,QAAQ,+CAA+C;AAAA,IAAA;AAEhF,QAAI,KAAK,SAAS,CAAC,aAAa,OAAO;AACrC,WAAK,SAAS,CAAC,IAAI,WAAW,KAAK,SAAS,CAAC,CAAC;AAAA,IAAA;AAEhD,QAAI,EAAE,KAAK,SAAS,CAAC,aAAa,QAAQ;AAClC,YAAA,IAAI,aAAa,SAAS,4BAA4B;AAAA,IAAA;AAE9D,SAAK,SAAS,CAAC,IAAI,aAAa,KAAK,SAAS,CAAC,CAAC;AAC3C,SAAA,SAAS,CAAC,IAAI,cAAc,KAAK,SAAS,CAAC,GAAG,IAAI;AAAA,EAAA;AAAA,EAG/C,KAAK,KAAU,OAAc,OAAe,UAAmB;;AACvE,UAAM,SAAS,WAAW,EAAE,OAAO,OAAO;AAC1C,QAAI,UAAU;AACZ,UAAI,OAAO;AACX,eAAS,IAAI,GAAG,KAAK,MAAM,WAAA,GAAc,KAAK;AAC5C,cAAM,KAAI,YAAO,CAAC,MAAR,mBAAY;AACtB,YAAI,KAAK,MAAM;AACb;AAAA,QAAA;AAEF,YAAI,KAAK,KAAK;AACL,iBAAA;AAAA,QAAA,OACF;AACL;AAAA,QAAA;AAAA,MACF;AAEF,UAAI,SAAS,IAAI;AACf,gBAAO,YAAO,IAAI,MAAX,mBAAe,QAAQ;AAAA,MAAC;AAAA,IACjC,OACK;AACL,eAAS,IAAI,GAAG,KAAK,MAAM,WAAA,GAAc,KAAK;AAC5C,cAAI,YAAO,CAAC,MAAR,mBAAY,QAAO,KAAK;AAC1B,kBAAO,YAAO,CAAC,MAAR,mBAAY,QAAQ;AAAA,QAAC;AAAA,MAC9B;AAAA,IACF;AAEF,UAAM,IAAI,aAAa,QAAQ,wBAAwB,GAAG,IAAI;AAAA,EAAA;AAElE;"}

package/dist/formula/mapping.js

@@ -0,0 +1,118 @@
+import { AddFunction } from "./functions/add.js";
+import { MinusFunction } from "./functions/minus.js";
+import { MultiplyFunction } from "./functions/multiply.js";
+import { DivideFunction } from "./functions/divide.js";
+import { ModFunction } from "./functions/mod.js";
+import { SumFunction } from "./functions/sum.js";
+import { ConcatFunction } from "./functions/concat.js";
+import { ConcatenateFunction } from "./functions/concatenate.js";
+import { EqFunction } from "./functions/eq.js";
+import { NeFunction } from "./functions/ne.js";
+import { GtFunction } from "./functions/gt.js";
+import { GteFunction } from "./functions/gte.js";
+import { LtFunction } from "./functions/lt.js";
+import { LteFunction } from "./functions/lte.js";
+import { NowFunction } from "./functions/now.js";
+import { AndFunction } from "./functions/and.js";
+import { OrFunction } from "./functions/or.js";
+import { IfFunction } from "./functions/if.js";
+import { IfErrorFunction } from "./functions/iferror.js";
+import { NotFunction } from "./functions/not.js";
+import { CountFunction } from "./functions/count.js";
+import { CountifFunction } from "./functions/countif.js";
+import { SumifFunction } from "./functions/sumif.js";
+import { VlookupFunction } from "./functions/vlookup.js";
+import { HlookupFunction } from "./functions/hlookup.js";
+import { LogFunction } from "./functions/log.js";
+import { Log10Function } from "./functions/log10.js";
+import { LnFunction } from "./functions/ln.js";
+import { AbsFunction } from "./functions/abs.js";
+import { ProductFunction } from "./functions/product.js";
+import { RandFunction } from "./functions/rand.js";
+import { PiFunction } from "./functions/pi.js";
+import { ExpFunction } from "./functions/exp.js";
+import { RadiansFunction } from "./functions/radians.js";
+import { PowerFunction } from "./functions/power.js";
+import { SqrtFunction } from "./functions/sqrt.js";
+import { RoundFunction } from "./functions/round.js";
+import { RoundupFunction } from "./functions/roundup.js";
+import { RounddownFunction } from "./functions/rounddown.js";
+import { SinFunction } from "./functions/sin.js";
+import { CosFunction } from "./functions/cos.js";
+import { TanFunction } from "./functions/tan.js";
+import { AsinFunction } from "./functions/asin.js";
+import { AcosFunction } from "./functions/acos.js";
+import { AtanFunction } from "./functions/atan.js";
+import { Atan2Function } from "./functions/atan2.js";
+import { CountaFunction } from "./functions/counta.js";
+import { AverageFunction } from "./functions/average.js";
+import { MaxFunction } from "./functions/max.js";
+import { MinFunction } from "./functions/min.js";
+import { LenFunction } from "./functions/len.js";
+import { LenbFunction } from "./functions/lenb.js";
+import { UminusFunction } from "./functions/uminus.js";
+import { RowFunction } from "./functions/row.js";
+import { ColFunction } from "./functions/col.js";
+const functions = {
+  abs: AbsFunction,
+  add: AddFunction,
+  divide: DivideFunction,
+  mod: ModFunction,
+  minus: MinusFunction,
+  uminus: UminusFunction,
+  multiply: MultiplyFunction,
+  pow: PowerFunction,
+  power: PowerFunction,
+  sqrt: SqrtFunction,
+  sum: SumFunction,
+  sumif: SumifFunction,
+  max: MaxFunction,
+  min: MinFunction,
+  average: AverageFunction,
+  count: CountFunction,
+  counta: CountaFunction,
+  countif: CountifFunction,
+  product: ProductFunction,
+  concat: ConcatFunction,
+  concatenate: ConcatenateFunction,
+  eq: EqFunction,
+  ne: NeFunction,
+  gt: GtFunction,
+  gte: GteFunction,
+  lt: LtFunction,
+  lte: LteFunction,
+  and: AndFunction,
+  or: OrFunction,
+  round: RoundFunction,
+  rounddown: RounddownFunction,
+  roundup: RoundupFunction,
+  if: IfFunction,
+  // @ts-expect-error iferror does not extends BaseFunction
+  iferror: IfErrorFunction,
+  not: NotFunction,
+  vlookup: VlookupFunction,
+  hlookup: HlookupFunction,
+  row: RowFunction,
+  col: ColFunction,
+  now: NowFunction,
+  rand: RandFunction,
+  log: LogFunction,
+  log10: Log10Function,
+  ln: LnFunction,
+  exp: ExpFunction,
+  pi: PiFunction,
+  radians: RadiansFunction,
+  sin: SinFunction,
+  cos: CosFunction,
+  tan: TanFunction,
+  asin: AsinFunction,
+  acos: AcosFunction,
+  atan: AtanFunction,
+  atan2: Atan2Function,
+  len: LenFunction,
+  lenb: LenbFunction
+};
+export {
+  functions
+};
+//# sourceMappingURL=mapping.js.map

package/dist/formula/mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.js","sources":["../../formula/mapping.ts"],"sourcesContent":["import { AddFunction } from './functions/add';\nimport { MinusFunction } from './functions/minus';\nimport { MultiplyFunction } from './functions/multiply';\nimport { DivideFunction } from './functions/divide';\nimport { ModFunction } from './functions/mod';\nimport { SumFunction } from './functions/sum';\nimport { ConcatFunction } from './functions/concat';\nimport { ConcatenateFunction } from './functions/concatenate';\nimport { EqFunction } from './functions/eq';\nimport { NeFunction } from './functions/ne';\nimport { GtFunction } from './functions/gt';\nimport { GteFunction } from './functions/gte';\nimport { LtFunction } from './functions/lt';\nimport { LteFunction } from './functions/lte';\nimport { NowFunction } from './functions/now';\nimport { AndFunction } from './functions/and';\nimport { OrFunction } from './functions/or';\nimport { IfFunction } from './functions/if';\nimport { IfErrorFunction } from './functions/iferror';\nimport { NotFunction } from './functions/not';\nimport { CountFunction } from './functions/count';\nimport { CountifFunction } from './functions/countif';\nimport { SumifFunction } from './functions/sumif';\nimport { VlookupFunction } from './functions/vlookup';\nimport { HlookupFunction } from './functions/hlookup';\nimport { LogFunction } from './functions/log';\nimport { Log10Function } from './functions/log10';\nimport { LnFunction } from './functions/ln';\nimport { AbsFunction } from './functions/abs';\nimport { ProductFunction } from './functions/product';\nimport { RandFunction } from './functions/rand';\nimport { PiFunction } from './functions/pi';\nimport { ExpFunction } from './functions/exp';\nimport { RadiansFunction } from './functions/radians';\nimport { PowerFunction } from './functions/power';\nimport { SqrtFunction } from './functions/sqrt';\nimport { RoundFunction } from './functions/round';\nimport { RoundupFunction } from './functions/roundup';\nimport { RounddownFunction } from './functions/rounddown';\nimport { SinFunction } from './functions/sin';\nimport { CosFunction } from './functions/cos';\nimport { TanFunction } from './functions/tan';\nimport { AsinFunction } from './functions/asin';\nimport { AcosFunction } from './functions/acos';\nimport { AtanFunction } from './functions/atan';\nimport { Atan2Function } from './functions/atan2';\nimport { CountaFunction } from './functions/counta';\nimport { AverageFunction } from './functions/average';\nimport { MaxFunction } from './functions/max';\nimport { MinFunction } from './functions/min';\nimport { LenFunction } from './functions/len';\nimport { LenbFunction } from './functions/lenb';\nimport { UminusFunction } from './functions/uminus';\nimport { RowFunction } from './functions/row';\nimport { ColFunction } from './functions/col';\nimport type { FunctionMapping } from './functions/__base';\n\nexport const functions: FunctionMapping = {\n  abs: AbsFunction,\n  add: AddFunction,\n  divide: DivideFunction,\n  mod: ModFunction,\n  minus: MinusFunction,\n  uminus: UminusFunction,\n  multiply: MultiplyFunction,\n  pow: PowerFunction,\n  power: PowerFunction,\n  sqrt: SqrtFunction,\n  sum: SumFunction,\n  sumif: SumifFunction,\n  max: MaxFunction,\n  min: MinFunction,\n  average: AverageFunction,\n  count: CountFunction,\n  counta: CountaFunction,\n  countif: CountifFunction,\n  product: ProductFunction,\n  concat: ConcatFunction,\n  concatenate: ConcatenateFunction,\n  eq: EqFunction,\n  ne: NeFunction,\n  gt: GtFunction,\n  gte: GteFunction,\n  lt: LtFunction,\n  lte: LteFunction,\n  and: AndFunction,\n  or: OrFunction,\n  round: RoundFunction,\n  rounddown: RounddownFunction,\n  roundup: RoundupFunction,\n  if: IfFunction,\n  // @ts-expect-error iferror does not extends BaseFunction\n  iferror: IfErrorFunction,\n  not: NotFunction,\n  vlookup: VlookupFunction,\n  hlookup: HlookupFunction,\n  row: RowFunction,\n  col: ColFunction,\n  now: NowFunction,\n  rand: RandFunction,\n  log: LogFunction,\n  log10: Log10Function,\n  ln: LnFunction,\n  exp: ExpFunction,\n  pi: PiFunction,\n  radians: RadiansFunction,\n  sin: SinFunction,\n  cos: CosFunction,\n  tan: TanFunction,\n  asin: AsinFunction,\n  acos: AcosFunction,\n  atan: AtanFunction,\n  atan2: Atan2Function,\n  len: LenFunction,\n  lenb: LenbFunction,\n};\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDO,MAAM,YAA6B;AAAA,EACxC,KAAK;AAAA,EACL,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,KAAK;AAAA,EACL,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,KAAK;AAAA,EACL,OAAO;AAAA,EACP,MAAM;AAAA,EACN,KAAK;AAAA,EACL,OAAO;AAAA,EACP,KAAK;AAAA,EACL,KAAK;AAAA,EACL,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,aAAa;AAAA,EACb,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,WAAW;AAAA,EACX,SAAS;AAAA,EACT,IAAI;AAAA;AAAA,EAEJ,SAAS;AAAA,EACT,KAAK;AAAA,EACL,SAAS;AAAA,EACT,SAAS;AAAA,EACT,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,OAAO;AAAA,EACP,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,KAAK;AAAA,EACL,MAAM;AACR;"}

package/dist/formula/solver.js

@@ -0,0 +1,70 @@
+import { Special } from "../constants.js";
+import { Table } from "../lib/table.js";
+import { Lexer, Parser, FormulaError } from "./evaluator.js";
+import { p2a } from "../lib/converters.js";
+const SOLVING = new Special("solving");
+const solveFormula = ({ value, table, raise = true, evaluates = true }) => {
+  var _a;
+  if (evaluates === null) {
+    return value;
+  }
+  let solved = value;
+  if (typeof value === "string") {
+    if (value.charAt(0) === "=") {
+      try {
+        const lexer = new Lexer(value.substring(1));
+        lexer.tokenize();
+        const parser = new Parser(lexer.tokens);
+        if (evaluates === false) {
+          return "=" + lexer.stringifyToRef(table);
+        }
+        const expr = parser.build();
+        solved = (_a = expr == null ? void 0 : expr.evaluate) == null ? void 0 : _a.call(expr, { table });
+      } catch (e) {
+        if (raise) {
+          throw e;
+        }
+        return null;
+      }
+    }
+  }
+  if (solved instanceof Table) {
+    solved = solveTable({ table: solved, raise })[0][0];
+  }
+  return solved;
+};
+const solveTable = ({ table, raise = true }) => {
+  const area = table.getArea();
+  return table.getMatrixFlatten({ area, evaluates: null }).map((row, i) => {
+    const y = area.top + i;
+    return row.map((value, j) => {
+      const x = area.left + j;
+      const address = p2a({ y, x });
+      const cache = table.getSolvedCache(address);
+      try {
+        if (cache === SOLVING) {
+          throw new FormulaError("#REF!", "References are circulating.", new Error(value));
+        } else if (cache instanceof FormulaError) {
+          throw cache;
+        } else if (cache != null) {
+          return cache;
+        }
+        table.setSolvedCache(address, SOLVING);
+        const solved = solveFormula({ value, table, raise });
+        table.setSolvedCache(address, solved);
+        return solved;
+      } catch (e) {
+        table.setSolvedCache(address, e);
+        if (raise) {
+          throw e;
+        }
+        return null;
+      }
+    });
+  });
+};
+export {
+  solveFormula,
+  solveTable
+};
+//# sourceMappingURL=solver.js.map

package/dist/formula/solver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver.js","sources":["../../formula/solver.ts"],"sourcesContent":["import { Special } from '../constants';\nimport { Table } from '../lib/table';\nimport { MatrixType } from '../types';\nimport { FormulaError, Lexer, Parser } from './evaluator';\nimport { p2a } from '../lib/converters';\n\nconst SOLVING = new Special('solving');\n\ntype SolveFormulaType = {\n  value: any;\n  table: Table;\n  raise?: boolean;\n  evaluates?: boolean | null;\n};\n\nexport const solveFormula = ({ value, table, raise = true, evaluates = true }: SolveFormulaType) => {\n  if (evaluates === null) {\n    return value;\n  }\n  let solved = value;\n  if (typeof value === 'string') {\n    if (value.charAt(0) === '=') {\n      try {\n        const lexer = new Lexer(value.substring(1));\n        lexer.tokenize();\n        const parser = new Parser(lexer.tokens);\n        if (evaluates === false) {\n          return '=' + lexer.stringifyToRef(table);\n        }\n        const expr = parser.build();\n        solved = expr?.evaluate?.({ table });\n      } catch (e) {\n        if (raise) {\n          throw e;\n        }\n        return null;\n      }\n    }\n  }\n  if (solved instanceof Table) {\n    solved = solveTable({ table: solved, raise })[0][0];\n  }\n  return solved;\n};\n\nexport const solveTable = ({ table, raise = true }: { table: Table; raise?: boolean }): MatrixType => {\n  const area = table.getArea();\n  return table.getMatrixFlatten({ area, evaluates: null }).map((row, i) => {\n    const y = area.top + i;\n    return row.map((value, j) => {\n      const x = area.left + j;\n      const address = p2a({ y, x });\n      const cache = table.getSolvedCache(address);\n\n      try {\n        if (cache === SOLVING) {\n          throw new FormulaError('#REF!', 'References are circulating.', new Error(value as string));\n        } else if (cache instanceof FormulaError) {\n          throw cache;\n        } else if (cache != null) {\n          return cache;\n        }\n        table.setSolvedCache(address, SOLVING);\n        const solved = solveFormula({ value, table, raise });\n        table.setSolvedCache(address, solved);\n        return solved;\n      } catch (e) {\n        table.setSolvedCache(address, e);\n        if (raise) {\n          throw e;\n        }\n        return null;\n      }\n    });\n  });\n};\n"],"names":[],"mappings":";;;;AAMA,MAAM,UAAU,IAAI,QAAQ,SAAS;AASxB,MAAA,eAAe,CAAC,EAAE,OAAO,OAAO,QAAQ,MAAM,YAAY,WAA6B;;AAClG,MAAI,cAAc,MAAM;AACf,WAAA;AAAA,EAAA;AAET,MAAI,SAAS;AACT,MAAA,OAAO,UAAU,UAAU;AAC7B,QAAI,MAAM,OAAO,CAAC,MAAM,KAAK;AACvB,UAAA;AACF,cAAM,QAAQ,IAAI,MAAM,MAAM,UAAU,CAAC,CAAC;AAC1C,cAAM,SAAS;AACf,cAAM,SAAS,IAAI,OAAO,MAAM,MAAM;AACtC,YAAI,cAAc,OAAO;AAChB,iBAAA,MAAM,MAAM,eAAe,KAAK;AAAA,QAAA;AAEnC,cAAA,OAAO,OAAO,MAAM;AAC1B,kBAAS,kCAAM,aAAN,8BAAiB,EAAE,MAAA;AAAA,eACrB,GAAG;AACV,YAAI,OAAO;AACH,gBAAA;AAAA,QAAA;AAED,eAAA;AAAA,MAAA;AAAA,IACT;AAAA,EACF;AAEF,MAAI,kBAAkB,OAAO;AAClB,aAAA,WAAW,EAAE,OAAO,QAAQ,OAAO,EAAE,CAAC,EAAE,CAAC;AAAA,EAAA;AAE7C,SAAA;AACT;AAEO,MAAM,aAAa,CAAC,EAAE,OAAO,QAAQ,WAA0D;AAC9F,QAAA,OAAO,MAAM,QAAQ;AACpB,SAAA,MAAM,iBAAiB,EAAE,MAAM,WAAW,KAAM,CAAA,EAAE,IAAI,CAAC,KAAK,MAAM;AACjE,UAAA,IAAI,KAAK,MAAM;AACrB,WAAO,IAAI,IAAI,CAAC,OAAO,MAAM;AACrB,YAAA,IAAI,KAAK,OAAO;AACtB,YAAM,UAAU,IAAI,EAAE,GAAG,GAAG;AACtB,YAAA,QAAQ,MAAM,eAAe,OAAO;AAEtC,UAAA;AACF,YAAI,UAAU,SAAS;AACrB,gBAAM,IAAI,aAAa,SAAS,+BAA+B,IAAI,MAAM,KAAe,CAAC;AAAA,QAAA,WAChF,iBAAiB,cAAc;AAClC,gBAAA;AAAA,QAAA,WACG,SAAS,MAAM;AACjB,iBAAA;AAAA,QAAA;AAEH,cAAA,eAAe,SAAS,OAAO;AACrC,cAAM,SAAS,aAAa,EAAE,OAAO,OAAO,OAAO;AAC7C,cAAA,eAAe,SAAS,MAAM;AAC7B,eAAA;AAAA,eACA,GAAG;AACJ,cAAA,eAAe,SAAS,CAAC;AAC/B,YAAI,OAAO;AACH,gBAAA;AAAA,QAAA;AAED,eAAA;AAAA,MAAA;AAAA,IACT,CACD;AAAA,EAAA,CACF;AACH;"}