@gridsheet/react-core 1.4.0 → 2.0.0-rc.0

package/dist/formula/functions/sumif.js

@@ -1,65 +0,0 @@
-import { FormulaError } from "../evaluator.js";
-import { solveTable } from "../solver.js";
-import { Table } from "../../lib/table.js";
-import { BaseFunction } from "./__base.js";
-import { ensureString, check } from "./__utils.js";
-class SumifFunction extends BaseFunction {
-  constructor() {
-    super(...arguments);
-    this.example = 'SUMIF(A1:A10,">20")';
-    this.helpText = ["Returns the sum of a series of cells."];
-    this.helpArgs = [
-      { name: "range1", description: "A condition range." },
-      {
-        name: "condition",
-        description: "A condition for summarization."
-      },
-      {
-        name: "range2",
-        description: "A range to be summarized.",
-        optional: true
-      }
-    ];
-  }
-  validate() {
-    if (this.bareArgs.length !== 2 && this.bareArgs.length !== 3) {
-      throw new FormulaError("#N/A", "Number of arguments for SUMIF is incorrect.");
-    }
-    if (this.bareArgs[2] != void 0 && this.bareArgs[2] instanceof Table) {
-      throw new FormulaError("#N/A", "3rd argument must be range.");
-    }
-    this.bareArgs[1] = ensureString(this.bareArgs[1]);
-  }
-  main(range, condition, sumRange) {
-    if (!(range instanceof Table)) {
-      return check(range, condition) ? range : 0;
-    }
-    const conditionMatrix = solveTable({ table: range });
-    let sumMatrix = conditionMatrix;
-    if (sumRange) {
-      const [top, left] = [sumRange.top, sumRange.left];
-      const area = {
-        top,
-        left,
-        bottom: top + sumRange.getNumRows(),
-        right: left + sumRange.getNumCols()
-      };
-      sumMatrix = solveTable({ table: this.table.trim(area) });
-    }
-    let total = 0;
-    conditionMatrix.forEach(
-      (row, y) => row.forEach((c, x) => {
-        var _a;
-        const s = ((_a = sumMatrix[y]) == null ? void 0 : _a[x]) || 0;
-        if (typeof s === "number" && check(c, condition)) {
-          total += s;
-        }
-      })
-    );
-    return total;
-  }
-}
-export {
-  SumifFunction
-};
-//# sourceMappingURL=sumif.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sumif.js","sources":["../../../formula/functions/sumif.ts"],"sourcesContent":["import { FormulaError } from '../evaluator';\nimport { solveTable } from '../solver';\nimport { Table } from '../../lib/table';\nimport { BaseFunction } from './__base';\nimport { check, ensureString } from './__utils';\nimport { AreaType } from '../../types';\n\nexport class SumifFunction extends BaseFunction {\n  example = 'SUMIF(A1:A10,\">20\")';\n  helpText = ['Returns the sum of a series of cells.'];\n  helpArgs = [\n    { name: 'range1', description: 'A condition range.' },\n    {\n      name: 'condition',\n      description: 'A condition for summarization.',\n    },\n    {\n      name: 'range2',\n      description: 'A range to be summarized.',\n      optional: true,\n    },\n  ];\n\n  protected validate() {\n    if (this.bareArgs.length !== 2 && this.bareArgs.length !== 3) {\n      throw new FormulaError('#N/A', 'Number of arguments for SUMIF is incorrect.');\n    }\n    if (this.bareArgs[2] != undefined && this.bareArgs[2] instanceof Table) {\n      throw new FormulaError('#N/A', '3rd argument must be range.');\n    }\n    this.bareArgs[1] = ensureString(this.bareArgs[1]);\n  }\n\n  protected main(range: Table, condition: string, sumRange: Table) {\n    if (!(range instanceof Table)) {\n      return check(range, condition) ? range : 0;\n    }\n    const conditionMatrix = solveTable({ table: range });\n    let sumMatrix = conditionMatrix;\n    if (sumRange) {\n      const [top, left] = [sumRange.top, sumRange.left];\n      const area: AreaType = {\n        top,\n        left,\n        bottom: top + sumRange.getNumRows(),\n        right: left + sumRange.getNumCols(),\n      };\n      sumMatrix = solveTable({ table: this.table.trim(area) });\n    }\n    let total = 0;\n    conditionMatrix.forEach((row, y) =>\n      row.forEach((c, x) => {\n        const s = sumMatrix[y]?.[x] || 0;\n        if (typeof s === 'number' && check(c, condition)) {\n          total += s;\n        }\n      }),\n    );\n    return total;\n  }\n}\n"],"names":[],"mappings":";;;;;AAOO,MAAM,sBAAsB,aAAa;AAAA,EAAzC,cAAA;AAAA,UAAA,GAAA,SAAA;AACK,SAAA,UAAA;AACV,SAAA,WAAW,CAAC,uCAAuC;AACxC,SAAA,WAAA;AAAA,MACT,EAAE,MAAM,UAAU,aAAa,qBAAqB;AAAA,MACpD;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,MACf;AAAA,MACA;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,UAAU;AAAA,MAAA;AAAA,IAEd;AAAA,EAAA;AAAA,EAEU,WAAW;AACnB,QAAI,KAAK,SAAS,WAAW,KAAK,KAAK,SAAS,WAAW,GAAG;AACtD,YAAA,IAAI,aAAa,QAAQ,6CAA6C;AAAA,IAAA;AAE1E,QAAA,KAAK,SAAS,CAAC,KAAK,UAAa,KAAK,SAAS,CAAC,aAAa,OAAO;AAChE,YAAA,IAAI,aAAa,QAAQ,6BAA6B;AAAA,IAAA;AAE9D,SAAK,SAAS,CAAC,IAAI,aAAa,KAAK,SAAS,CAAC,CAAC;AAAA,EAAA;AAAA,EAGxC,KAAK,OAAc,WAAmB,UAAiB;AAC3D,QAAA,EAAE,iBAAiB,QAAQ;AAC7B,aAAO,MAAM,OAAO,SAAS,IAAI,QAAQ;AAAA,IAAA;AAE3C,UAAM,kBAAkB,WAAW,EAAE,OAAO,OAAO;AACnD,QAAI,YAAY;AAChB,QAAI,UAAU;AACN,YAAA,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI;AAChD,YAAM,OAAiB;AAAA,QACrB;AAAA,QACA;AAAA,QACA,QAAQ,MAAM,SAAS,WAAW;AAAA,QAClC,OAAO,OAAO,SAAS,WAAW;AAAA,MACpC;AACY,kBAAA,WAAW,EAAE,OAAO,KAAK,MAAM,KAAK,IAAI,GAAG;AAAA,IAAA;AAEzD,QAAI,QAAQ;AACI,oBAAA;AAAA,MAAQ,CAAC,KAAK,MAC5B,IAAI,QAAQ,CAAC,GAAG,MAAM;;AACpB,cAAM,MAAI,eAAU,CAAC,MAAX,mBAAe,OAAM;AAC/B,YAAI,OAAO,MAAM,YAAY,MAAM,GAAG,SAAS,GAAG;AACvC,mBAAA;AAAA,QAAA;AAAA,MAEZ,CAAA;AAAA,IACH;AACO,WAAA;AAAA,EAAA;AAEX;"}

package/dist/formula/functions/tan.js

@@ -1,29 +0,0 @@
-import { FormulaError } from "../evaluator.js";
-import { BaseFunction } from "./__base.js";
-import { ensureNumber } from "./__utils.js";
-class TanFunction extends BaseFunction {
-  constructor() {
-    super(...arguments);
-    this.example = "TAN(1)";
-    this.helpText = ["Returns the tan of the angle specified in radians."];
-    this.helpArgs = [
-      {
-        name: "angle",
-        description: "An angle in radians, at which you want the tan."
-      }
-    ];
-  }
-  validate() {
-    if (this.bareArgs.length !== 1) {
-      throw new FormulaError("#N/A", "Number of arguments for TAN is incorrect.");
-    }
-    this.bareArgs = this.bareArgs.map((arg) => ensureNumber(arg));
-  }
-  main(angle) {
-    return Math.tan(angle);
-  }
-}
-export {
-  TanFunction
-};
-//# sourceMappingURL=tan.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tan.js","sources":["../../../formula/functions/tan.ts"],"sourcesContent":["import { FormulaError } from '../evaluator';\nimport { BaseFunction } from './__base';\nimport { ensureNumber } from './__utils';\n\nexport class TanFunction extends BaseFunction {\n  example = 'TAN(1)';\n  helpText = ['Returns the tan of the angle specified in radians.'];\n  helpArgs = [\n    {\n      name: 'angle',\n      description: 'An angle in radians, at which you want the tan.',\n    },\n  ];\n\n  protected validate() {\n    if (this.bareArgs.length !== 1) {\n      throw new FormulaError('#N/A', 'Number of arguments for TAN is incorrect.');\n    }\n    this.bareArgs = this.bareArgs.map((arg) => ensureNumber(arg));\n  }\n\n  protected main(angle: number) {\n    return Math.tan(angle);\n  }\n}\n"],"names":[],"mappings":";;;AAIO,MAAM,oBAAoB,aAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA;AACK,SAAA,UAAA;AACV,SAAA,WAAW,CAAC,oDAAoD;AACrD,SAAA,WAAA;AAAA,MACT;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,MAAA;AAAA,IAEjB;AAAA,EAAA;AAAA,EAEU,WAAW;AACf,QAAA,KAAK,SAAS,WAAW,GAAG;AACxB,YAAA,IAAI,aAAa,QAAQ,2CAA2C;AAAA,IAAA;AAEvE,SAAA,WAAW,KAAK,SAAS,IAAI,CAAC,QAAQ,aAAa,GAAG,CAAC;AAAA,EAAA;AAAA,EAGpD,KAAK,OAAe;AACrB,WAAA,KAAK,IAAI,KAAK;AAAA,EAAA;AAEzB;"}

package/dist/formula/functions/uminus.js

@@ -1,24 +0,0 @@
-import { FormulaError } from "../evaluator.js";
-import { BaseFunction } from "./__base.js";
-import { ensureNumber } from "./__utils.js";
-class UminusFunction extends BaseFunction {
-  constructor() {
-    super(...arguments);
-    this.example = "UMINUS(4)";
-    this.helpText = ["Returns a number with positive and negative values reversed."];
-    this.helpArgs = [{ name: "value1", description: "A number that will be subtracted." }];
-  }
-  validate() {
-    if (this.bareArgs.length !== 1) {
-      throw new FormulaError("#N/A", "A single numerical value is only required.");
-    }
-    this.bareArgs = this.bareArgs.map((arg) => ensureNumber(arg));
-  }
-  main(v1) {
-    return -v1;
-  }
-}
-export {
-  UminusFunction
-};
-//# sourceMappingURL=uminus.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"uminus.js","sources":["../../../formula/functions/uminus.ts"],"sourcesContent":["import { FormulaError } from '../evaluator';\nimport { BaseFunction } from './__base';\nimport { ensureNumber } from './__utils';\n\nexport class UminusFunction extends BaseFunction {\n  example = 'UMINUS(4)';\n  helpText = ['Returns a number with positive and negative values reversed.'];\n  helpArgs = [{ name: 'value1', description: 'A number that will be subtracted.' }];\n\n  protected validate() {\n    if (this.bareArgs.length !== 1) {\n      throw new FormulaError('#N/A', 'A single numerical value is only required.');\n    }\n    this.bareArgs = this.bareArgs.map((arg) => ensureNumber(arg));\n  }\n\n  protected main(v1: number) {\n    return -v1;\n  }\n}\n"],"names":[],"mappings":";;;AAIO,MAAM,uBAAuB,aAAa;AAAA,EAA1C,cAAA;AAAA,UAAA,GAAA,SAAA;AACK,SAAA,UAAA;AACV,SAAA,WAAW,CAAC,8DAA8D;AAC1E,SAAA,WAAW,CAAC,EAAE,MAAM,UAAU,aAAa,qCAAqC;AAAA,EAAA;AAAA,EAEtE,WAAW;AACf,QAAA,KAAK,SAAS,WAAW,GAAG;AACxB,YAAA,IAAI,aAAa,QAAQ,4CAA4C;AAAA,IAAA;AAExE,SAAA,WAAW,KAAK,SAAS,IAAI,CAAC,QAAQ,aAAa,GAAG,CAAC;AAAA,EAAA;AAAA,EAGpD,KAAK,IAAY;AACzB,WAAO,CAAC;AAAA,EAAA;AAEZ;"}

package/dist/formula/functions/vlookup.js

@@ -1,75 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,119 +0,0 @@
-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,
-  column: 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

@@ -1 +0,0 @@
-{"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  column: 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,QAAQ;AAAA,EACR,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

@@ -1,70 +0,0 @@
-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, origin }) => {
-  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), { origin });
-        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, origin: { y, x } });
-        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

@@ -1 +0,0 @@
-{"version":3,"file":"solver.js","sources":["../../formula/solver.ts"],"sourcesContent":["import { Special } from '../constants';\nimport { Table } from '../lib/table';\nimport { MatrixType, PointType } 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  origin?: PointType;\n};\n\nexport const solveFormula = ({ value, table, raise = true, evaluates = true, origin }: 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), { origin });\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, origin: { y, x } });\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;AAUxB,MAAA,eAAe,CAAC,EAAE,OAAO,OAAO,QAAQ,MAAM,YAAY,MAAM,aAA+B;;AAC1G,MAAI,cAAc,MAAM;AACf,WAAA;AAAA,EAAA;AAET,MAAI,SAAS;AACT,MAAA,OAAO,UAAU,UAAU;AAC7B,QAAI,MAAM,OAAO,CAAC,MAAM,KAAK;AACvB,UAAA;AACI,cAAA,QAAQ,IAAI,MAAM,MAAM,UAAU,CAAC,GAAG,EAAE,QAAQ;AACtD,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;AAC/B,cAAA,SAAS,aAAa,EAAE,OAAO,OAAO,OAAO,QAAQ,EAAE,GAAG,EAAE,GAAG;AAC/D,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;"}