@gridsheet/core 3.0.0-rc.8

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

@@ -0,0 +1 @@
+{"version":3,"file":"add.js","sources":["../../../src/formula/functions/add.ts"],"sourcesContent":["import dayjs from 'dayjs';\n\nimport { FormulaError } from '../formula-error';\nimport { BaseFunction, type FunctionCategory, type FunctionArgumentDefinition } from './__base';\nimport { ensureNumber } from './__utils';\nimport { Time } from '../../lib/time';\nimport { SECONDS_IN_DAY } from '../../constants';\n\nconst description = `Returns the sum of two numbers.\nThis is the same as the '+' operator.`;\n\nexport class AddFunction extends BaseFunction {\n  example = 'ADD(2, 3)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'value1', description: 'First additive.', acceptedTypes: ['number', 'date', 'time'] },\n    { name: 'value2', description: 'Second additive.', acceptedTypes: ['number', 'date', 'time'] },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected main(v1: number | Date | Time, v2: number | Date | Time) {\n    if (typeof v1 === 'number' && typeof v2 === 'number') {\n      return v1 + v2;\n    }\n    if (v1 instanceof Date && Time.is(v2)) {\n      return Time.ensure(v2).add(v1);\n    }\n    if (Time.is(v1) && v2 instanceof Date) {\n      return Time.ensure(v1).add(v2);\n    }\n    if (v1 instanceof Date && typeof v2 === 'number') {\n      return dayjs(v1)\n        .add(v2 * SECONDS_IN_DAY, 'second')\n        .toDate();\n    }\n    if (typeof v1 === 'number' && v2 instanceof Date) {\n      return dayjs(v2)\n        .add(v1 * SECONDS_IN_DAY, 'second')\n        .toDate();\n    }\n    try {\n      return ensureNumber(v1, { alternative: 0 }) + ensureNumber(v2, { alternative: 0 });\n    } catch (e) {\n      throw new FormulaError('#VALUE!', 'Mismatched types for augend or addend.');\n    }\n  }\n}\n"],"names":["description","AddFunction","BaseFunction","v1","v2","Time","dayjs","SECONDS_IN_DAY","ensureNumber","FormulaError"],"mappings":";;;;;;AAQA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,aACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,UAAU,aAAa,mBAAmB,eAAe,CAAC,UAAU,QAAQ,MAAM,EAAE;AAAA,MAC5F,EAAE,MAAM,UAAU,aAAa,oBAAoB,eAAe,CAAC,UAAU,QAAQ,MAAM,EAAE;AAAA,IAC/F,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAA0BC,GAA0B;AACjE,QAAI,OAAOD,KAAO,YAAY,OAAOC,KAAO;AAC1C,aAAOD,IAAKC;AAEd,QAAID,aAAc,QAAQE,EAAK,GAAGD,CAAE;AAClC,aAAOC,EAAK,OAAOD,CAAE,EAAE,IAAID,CAAE;AAE/B,QAAIE,EAAK,GAAGF,CAAE,KAAKC,aAAc;AAC/B,aAAOC,EAAK,OAAOF,CAAE,EAAE,IAAIC,CAAE;AAE/B,QAAID,aAAc,QAAQ,OAAOC,KAAO;AAC/B,aAAAE,EAAMH,CAAE,EACZ,IAAIC,IAAKG,GAAgB,QAAQ,EACjC,OAAO;AAEZ,QAAI,OAAOJ,KAAO,YAAYC,aAAc;AACnC,aAAAE,EAAMF,CAAE,EACZ,IAAID,IAAKI,GAAgB,QAAQ,EACjC,OAAO;AAER,QAAA;AACF,aAAOC,EAAaL,GAAI,EAAE,aAAa,EAAE,CAAC,IAAIK,EAAaJ,GAAI,EAAE,aAAa,EAAA,CAAG;AAAA,YACvE;AACJ,YAAA,IAAIK,EAAa,WAAW,wCAAwC;AAAA,IAAA;AAAA,EAC5E;AAEJ;"}

package/dist/formula/functions/and.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class AndFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): boolean;
+}
+//# sourceMappingURL=and.d.ts.map

package/dist/formula/functions/and.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"and.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/and.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,SAAqB;IAC5B,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAOhC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IAEvC,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE;CAGhC"}

package/dist/formula/functions/and.js

@@ -0,0 +1,23 @@
+import { BaseFunction as t } from "./__base.js";
+import { ensureBoolean as i } from "./__utils.js";
+const n = `Returns TRUE if all arguments are logically TRUE.
+Returns FALSE if any argument is logically FALSE.`;
+class l extends t {
+  constructor() {
+    super(...arguments), this.example = "AND(A1=1, A2=2)", this.description = n, this.defs = [
+      {
+        name: "expression",
+        description: "Logical expressions to evaluate.",
+        acceptedTypes: ["boolean", "number"],
+        variadic: !0
+      }
+    ], this.category = "logical";
+  }
+  main(...r) {
+    return r.map((e) => i(e)).reduce((e, s) => e && s);
+  }
+}
+export {
+  l as AndFunction
+};
+//# sourceMappingURL=and.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"and.js","sources":["../../../src/formula/functions/and.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureBoolean } from './__utils';\n\nconst description = `Returns TRUE if all arguments are logically TRUE.\nReturns FALSE if any argument is logically FALSE.`;\n\nexport class AndFunction extends BaseFunction {\n  example = 'AND(A1=1, A2=2)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'expression',\n      description: 'Logical expressions to evaluate.',\n      acceptedTypes: ['boolean', 'number'],\n      variadic: true,\n    },\n  ];\n  category: FunctionCategory = 'logical';\n\n  protected main(...values: any[]) {\n    return values.map((v) => ensureBoolean(v)).reduce((a, b) => a && b);\n  }\n}\n"],"names":["description","AndFunction","BaseFunction","values","v","ensureBoolean","a","b"],"mappings":";;AAGA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,mBACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,WAAW,QAAQ;AAAA,QACnC,UAAU;AAAA,MAAA;AAAA,IAEd,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,QAAQG,GAAe;AAC/B,WAAOA,EAAO,IAAI,CAACC,MAAMC,EAAcD,CAAC,CAAC,EAAE,OAAO,CAACE,GAAGC,MAAMD,KAAKC,CAAC;AAAA,EAAA;AAEtE;"}

package/dist/formula/functions/arrayformula.d.ts

@@ -0,0 +1,12 @@
+import { Spilling } from '../../sentinels';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class ArrayformulaFunction extends BaseFunction {
+    autoSpilling: boolean;
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected broadcastDisabled: boolean;
+    protected main(value: any): any[] | Spilling;
+}
+//# sourceMappingURL=arrayformula.d.ts.map

package/dist/formula/functions/arrayformula.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayformula.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/arrayformula.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAKtF,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,YAAY,UAAQ;IACpB,OAAO,SAAmC;IAC1C,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAOhC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IACvC,SAAS,CAAC,iBAAiB,UAAQ;IAEnC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG;CAY1B"}

package/dist/formula/functions/arrayformula.js

@@ -0,0 +1,24 @@
+import { Sheet as r } from "../../lib/sheet.js";
+import { Spilling as t } from "../../sentinels.js";
+import { BaseFunction as i } from "./__base.js";
+const a = `Enables the display of values returned from an array formula into multiple rows and/or columns.
+If the argument is already a Spilling, it is returned as-is. If it is a Sheet (range reference), the field matrix is extracted and wrapped in a Spilling. Otherwise the value is wrapped as a single-element Spilling.`;
+class p extends i {
+  constructor() {
+    super(...arguments), this.autoSpilling = !0, this.example = "ARRAYFORMULA(A1:A10 * B1:B10)", this.description = a, this.defs = [
+      {
+        name: "value",
+        description: "The array expression or value to evaluate.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix", "any"]
+      }
+    ], this.category = "logical", this.broadcastDisabled = !0;
+  }
+  main(e) {
+    return t.is(e) ? e : e instanceof r ? e._toValueMatrix() : Array.isArray(e) ? e : [[e]];
+  }
+}
+export {
+  p as ArrayformulaFunction
+};
+//# sourceMappingURL=arrayformula.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrayformula.js","sources":["../../../src/formula/functions/arrayformula.ts"],"sourcesContent":["import { Sheet } from '../../lib/sheet';\nimport { Spilling } from '../../sentinels';\nimport { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\n\nconst description = `Enables the display of values returned from an array formula into multiple rows and/or columns.\nIf the argument is already a Spilling, it is returned as-is. If it is a Sheet (range reference), the field matrix is extracted and wrapped in a Spilling. Otherwise the value is wrapped as a single-element Spilling.`;\n\nexport class ArrayformulaFunction extends BaseFunction {\n  autoSpilling = true;\n  example = 'ARRAYFORMULA(A1:A10 * B1:B10)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'The array expression or value to evaluate.',\n      takesMatrix: true,\n      acceptedTypes: ['matrix', 'any'],\n    },\n  ];\n  category: FunctionCategory = 'logical';\n  protected broadcastDisabled = true;\n\n  protected main(value: any) {\n    if (Spilling.is(value)) {\n      return value;\n    }\n    if (value instanceof Sheet) {\n      return value._toValueMatrix();\n    }\n    if (Array.isArray(value)) {\n      return value;\n    }\n    return [[value]];\n  }\n}\n"],"names":["description","ArrayformulaFunction","BaseFunction","value","Spilling","Sheet"],"mappings":";;;AAIA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAA6BC,EAAa;AAAA,EAAhD,cAAA;AAAA,UAAA,GAAA,SAAA,GACU,KAAA,eAAA,IACL,KAAA,UAAA,iCACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,KAAK;AAAA,MAAA;AAAA,IAEnC,GAC6B,KAAA,WAAA,WAC7B,KAAU,oBAAoB;AAAA,EAAA;AAAA,EAEpB,KAAKG,GAAY;AACrB,WAAAC,EAAS,GAAGD,CAAK,IACZA,IAELA,aAAiBE,IACZF,EAAM,eAAe,IAE1B,MAAM,QAAQA,CAAK,IACdA,IAEF,CAAC,CAACA,CAAK,CAAC;AAAA,EAAA;AAEnB;"}

package/dist/formula/functions/average.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class AverageFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): number;
+}
+//# sourceMappingURL=average.d.ts.map

package/dist/formula/functions/average.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"average.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/average.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAY,MAAM,UAAU,CAAC;AAKhG,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,OAAO,SAA2B;IAClC,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAQhC;IACF,QAAQ,EAAE,gBAAgB,CAAgB;IAE1C,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE;CA2BhC"}

package/dist/formula/functions/average.js

@@ -0,0 +1,40 @@
+import { FormulaError as o } from "../formula-error.js";
+import { BaseFunction as a, isMatrix as n } from "./__base.js";
+import { eachMatrix as u, ensureNumber as c } from "./__utils.js";
+const m = "Returns the average of a series of numbers or cells.";
+class l extends a {
+  constructor() {
+    super(...arguments), this.example = "AVERAGE(A2:A100, 101)", this.description = m, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to average.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  main(...i) {
+    let t = 0, e = 0;
+    if (i.forEach((s) => {
+      if (n(s))
+        u(
+          s,
+          (r) => {
+            typeof r == "number" && (t += r, e++);
+          },
+          this.at
+        );
+      else {
+        const r = c(s);
+        t += r, e++;
+      }
+    }), e === 0)
+      throw new o("#DIV/0!", "Evaluation of function AVERAGE caused a divide by zero error.");
+    return t / e;
+  }
+}
+export {
+  l as AverageFunction
+};
+//# sourceMappingURL=average.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"average.js","sources":["../../../src/formula/functions/average.ts"],"sourcesContent":["import { FormulaError } from '../formula-error';\nimport { BaseFunction, FunctionCategory, FunctionArgumentDefinition, isMatrix } from './__base';\nimport { ensureNumber, eachMatrix } from './__utils';\n\nconst description = `Returns the average of a series of numbers or cells.`;\n\nexport class AverageFunction extends BaseFunction {\n  example = 'AVERAGE(A2:A100, 101)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'Numbers or ranges to average.',\n      takesMatrix: true,\n      acceptedTypes: ['number', 'matrix'],\n      variadic: true,\n    },\n  ];\n  category: FunctionCategory = 'statistics';\n\n  protected main(...values: any[]) {\n    let sum = 0;\n    let count = 0;\n    values.forEach((val) => {\n      if (isMatrix(val)) {\n        eachMatrix(\n          val,\n          (v) => {\n            if (typeof v === 'number') {\n              sum += v;\n              count++;\n            }\n          },\n          this.at,\n        );\n      } else {\n        const num = ensureNumber(val);\n        sum += num;\n        count++;\n      }\n    });\n\n    if (count === 0) {\n      throw new FormulaError('#DIV/0!', 'Evaluation of function AVERAGE caused a divide by zero error.');\n    }\n    return sum / count;\n  }\n}\n"],"names":["description","AverageFunction","BaseFunction","values","sum","count","val","isMatrix","eachMatrix","v","num","ensureNumber","FormulaError"],"mappings":";;;AAIA,MAAMA,IAAc;AAEb,MAAMC,UAAwBC,EAAa;AAAA,EAA3C,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,yBACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,QAAQ;AAAA,QAClC,UAAU;AAAA,MAAA;AAAA,IAEd,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,QAAQG,GAAe;AAC/B,QAAIC,IAAM,GACNC,IAAQ;AAoBZ,QAnBOF,EAAA,QAAQ,CAACG,MAAQ;AAClB,UAAAC,EAASD,CAAG;AACd,QAAAE;AAAA,UACEF;AAAA,UACA,CAACG,MAAM;AACD,YAAA,OAAOA,KAAM,aACRL,KAAAK,GACPJ;AAAA,UAEJ;AAAA,UACA,KAAK;AAAA,QACP;AAAA,WACK;AACC,cAAAK,IAAMC,EAAaL,CAAG;AACrB,QAAAF,KAAAM,GACPL;AAAA,MAAA;AAAA,IACF,CACD,GAEGA,MAAU;AACN,YAAA,IAAIO,EAAa,WAAW,+DAA+D;AAEnG,WAAOR,IAAMC;AAAA,EAAA;AAEjB;"}

package/dist/formula/functions/concat.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class ConcatFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): string;
+}
+//# sourceMappingURL=concat.d.ts.map

package/dist/formula/functions/concat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/concat.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,SAA8B;IACrC,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAWhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG;CAGhC"}

package/dist/formula/functions/concat.js

@@ -0,0 +1,27 @@
+import { BaseFunction as o } from "./__base.js";
+import { ensureString as e } from "./__utils.js";
+const a = `Returns the concatenation of two values.
+This is the same as the '&' operator.`;
+class c extends o {
+  constructor() {
+    super(...arguments), this.example = 'CONCAT("Hello", "World")', this.description = a, this.defs = [
+      {
+        name: "value1",
+        description: "A value to be concatenated with value2.",
+        acceptedTypes: ["string", "number", "boolean"]
+      },
+      {
+        name: "value2",
+        description: "A value to be concatenated with value1",
+        acceptedTypes: ["string", "number", "boolean"]
+      }
+    ], this.category = "text";
+  }
+  main(t, n) {
+    return e(t) + e(n);
+  }
+}
+export {
+  c as ConcatFunction
+};
+//# sourceMappingURL=concat.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat.js","sources":["../../../src/formula/functions/concat.ts"],"sourcesContent":["import { FormulaError } from '../formula-error';\nimport { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureString } from './__utils';\n\nconst description = `Returns the concatenation of two values.\nThis is the same as the '&' operator.`;\n\nexport class ConcatFunction extends BaseFunction {\n  example = 'CONCAT(\"Hello\", \"World\")';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value1',\n      description: 'A value to be concatenated with value2.',\n      acceptedTypes: ['string', 'number', 'boolean'],\n    },\n    {\n      name: 'value2',\n      description: 'A value to be concatenated with value1',\n      acceptedTypes: ['string', 'number', 'boolean'],\n    },\n  ];\n  category: FunctionCategory = 'text';\n\n  protected main(v1: any, v2: any) {\n    return ensureString(v1) + ensureString(v2);\n  }\n}\n"],"names":["description","ConcatFunction","BaseFunction","v1","v2","ensureString"],"mappings":";;AAIA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAuBC,EAAa;AAAA,EAA1C,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,4BACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,UAAU,SAAS;AAAA,MAC/C;AAAA,MACA;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,UAAU,SAAS;AAAA,MAAA;AAAA,IAEjD,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAASC,GAAS;AAC/B,WAAOC,EAAaF,CAAE,IAAIE,EAAaD,CAAE;AAAA,EAAA;AAE7C;"}

package/dist/formula/functions/count.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class CountFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): number;
+}
+//# sourceMappingURL=count.d.ts.map

package/dist/formula/functions/count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/count.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAY,MAAM,UAAU,CAAC;AAKhG,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,SAAiC;IACxC,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAQhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE;CAoBhC"}

package/dist/formula/functions/count.js

@@ -0,0 +1,32 @@
+import { BaseFunction as i, isMatrix as o } from "./__base.js";
+import { eachMatrix as n, ensureNumber as a } from "./__utils.js";
+const u = "Returns the count of a series of numbers or cells.";
+class f extends i {
+  constructor() {
+    super(...arguments), this.example = "COUNT(A2:A100,B2:B100,4,26)", this.description = u, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to count.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  main(...r) {
+    let e = 0;
+    return r.forEach((t) => {
+      o(t) ? n(
+        t,
+        (s) => {
+          typeof s == "number" && e++;
+        },
+        this.at
+      ) : (a(t), e++);
+    }), e;
+  }
+}
+export {
+  f as CountFunction
+};
+//# sourceMappingURL=count.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"count.js","sources":["../../../src/formula/functions/count.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition, isMatrix } from './__base';\nimport { ensureNumber, eachMatrix } from './__utils';\n\nconst description = `Returns the count of a series of numbers or cells.`;\n\nexport class CountFunction extends BaseFunction {\n  example = 'COUNT(A2:A100,B2:B100,4,26)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'Numbers or ranges to count.',\n      takesMatrix: true,\n      acceptedTypes: ['number', 'matrix'],\n      variadic: true,\n    },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected main(...values: any[]) {\n    let count = 0;\n    values.forEach((val) => {\n      if (isMatrix(val)) {\n        eachMatrix(\n          val,\n          (v) => {\n            if (typeof v === 'number') {\n              count++;\n            }\n          },\n          this.at,\n        );\n      } else {\n        ensureNumber(val);\n        count++;\n      }\n    });\n    return count;\n  }\n}\n"],"names":["description","CountFunction","BaseFunction","values","count","val","isMatrix","eachMatrix","v","ensureNumber"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAsBC,EAAa;AAAA,EAAzC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,+BACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,QAAQ;AAAA,QAClC,UAAU;AAAA,MAAA;AAAA,IAEd,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,QAAQG,GAAe;AAC/B,QAAIC,IAAQ;AACL,WAAAD,EAAA,QAAQ,CAACE,MAAQ;AAClB,MAAAC,EAASD,CAAG,IACdE;AAAA,QACEF;AAAA,QACA,CAACG,MAAM;AACD,UAAA,OAAOA,KAAM,YACfJ;AAAA,QAEJ;AAAA,QACA,KAAK;AAAA,MACP,KAEAK,EAAaJ,CAAG,GAChBD;AAAA,IACF,CACD,GACMA;AAAA,EAAA;AAEX;"}

package/dist/formula/functions/counta.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class CountaFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(...values: any[]): number;
+}
+//# sourceMappingURL=counta.d.ts.map

package/dist/formula/functions/counta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"counta.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/counta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAKtF,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,SAAkC;IACzC,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAQhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE;CAehC"}

package/dist/formula/functions/counta.js

@@ -0,0 +1,32 @@
+import { BaseFunction as s } from "./__base.js";
+import { eachMatrix as i } from "./__utils.js";
+const n = "Returns the number of values in the data set.";
+class m extends s {
+  constructor() {
+    super(...arguments), this.example = "COUNTA(A2:A100,B2:B100,4,26)", this.description = n, this.defs = [
+      {
+        name: "value",
+        description: "Values or ranges to count.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  main(...r) {
+    let t = 0;
+    return r.forEach((a) => {
+      i(
+        a,
+        (e) => {
+          e != null && e !== "" && t++;
+        },
+        this.at
+      );
+    }), t;
+  }
+}
+export {
+  m as CountaFunction
+};
+//# sourceMappingURL=counta.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"counta.js","sources":["../../../src/formula/functions/counta.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { eachMatrix } from './__utils';\n\nconst description = `Returns the number of values in the data set.`;\n\nexport class CountaFunction extends BaseFunction {\n  example = 'COUNTA(A2:A100,B2:B100,4,26)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'Values or ranges to count.',\n      takesMatrix: true,\n      acceptedTypes: ['number', 'matrix'],\n      variadic: true,\n    },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected main(...values: any[]) {\n    let count = 0;\n    values.forEach((val) => {\n      eachMatrix(\n        val,\n        (v) => {\n          if (v != null && v !== '') {\n            count++;\n          }\n        },\n        this.at,\n      );\n    });\n    return count;\n  }\n}\n"],"names":["description","CountaFunction","BaseFunction","values","count","val","eachMatrix","v"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAuBC,EAAa;AAAA,EAA1C,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,gCACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,QAAQ;AAAA,QAClC,UAAU;AAAA,MAAA;AAAA,IAEd,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,QAAQG,GAAe;AAC/B,QAAIC,IAAQ;AACL,WAAAD,EAAA,QAAQ,CAACE,MAAQ;AACtB,MAAAC;AAAA,QACED;AAAA,QACA,CAACE,MAAM;AACD,UAAAA,KAAK,QAAQA,MAAM,MACrBH;AAAA,QAEJ;AAAA,QACA,KAAK;AAAA,MACP;AAAA,IAAA,CACD,GACMA;AAAA,EAAA;AAEX;"}

package/dist/formula/functions/divide.d.ts

@@ -0,0 +1,10 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class DivideFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected validate(args: any[]): any[];
+    protected main(divided: number, divisor: number): number;
+}
+//# sourceMappingURL=divide.d.ts.map

package/dist/formula/functions/divide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/divide.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,SAAkB;IACzB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAWhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;IAQtC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAGhD"}

package/dist/formula/functions/divide.js

@@ -0,0 +1,34 @@
+import { FormulaError as r } from "../formula-error.js";
+import { BaseFunction as n } from "./__base.js";
+import { ensureNumber as o } from "./__utils.js";
+const s = `Returns the result of dividing one number by another.
+This is the same as the '/' operator.`;
+class c extends n {
+  constructor() {
+    super(...arguments), this.example = "DIVIDE(4, 2)", this.description = s, this.defs = [
+      {
+        name: "dividend",
+        description: "A number that will be divided by divisor.",
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "divisor",
+        description: "A number that will divide a dividend. Must be non-zero.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  validate(t) {
+    const e = super.validate(t).map((i) => o(i));
+    if (e[1] === 0)
+      throw new r("#DIV/0!", "The second argument must be non-zero.");
+    return e;
+  }
+  main(t, e) {
+    return t / e;
+  }
+}
+export {
+  c as DivideFunction
+};
+//# sourceMappingURL=divide.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"divide.js","sources":["../../../src/formula/functions/divide.ts"],"sourcesContent":["import { FormulaError } from '../formula-error';\nimport { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureNumber } from './__utils';\n\nconst description = `Returns the result of dividing one number by another.\nThis is the same as the '/' operator.`;\n\nexport class DivideFunction extends BaseFunction {\n  example = 'DIVIDE(4, 2)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'dividend',\n      description: 'A number that will be divided by divisor.',\n      acceptedTypes: ['number'],\n    },\n    {\n      name: 'divisor',\n      description: 'A number that will divide a dividend. Must be non-zero.',\n      acceptedTypes: ['number'],\n    },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected validate(args: any[]): any[] {\n    const validated = super.validate(args).map((arg) => ensureNumber(arg));\n    if (validated[1] === 0) {\n      throw new FormulaError('#DIV/0!', 'The second argument must be non-zero.');\n    }\n    return validated;\n  }\n\n  protected main(divided: number, divisor: number) {\n    return divided / divisor;\n  }\n}\n"],"names":["description","DivideFunction","BaseFunction","args","validated","arg","ensureNumber","FormulaError","divided","divisor"],"mappings":";;;AAIA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAuBC,EAAa;AAAA,EAA1C,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,gBACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,QAAQ;AAAA,MAC1B;AAAA,MACA;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,QAAQ;AAAA,MAAA;AAAA,IAE5B,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,SAASG,GAAoB;AAC/B,UAAAC,IAAY,MAAM,SAASD,CAAI,EAAE,IAAI,CAACE,MAAQC,EAAaD,CAAG,CAAC;AACjE,QAAAD,EAAU,CAAC,MAAM;AACb,YAAA,IAAIG,EAAa,WAAW,uCAAuC;AAEpE,WAAAH;AAAA,EAAA;AAAA,EAGC,KAAKI,GAAiBC,GAAiB;AAC/C,WAAOD,IAAUC;AAAA,EAAA;AAErB;"}

package/dist/formula/functions/eq.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class EqFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): boolean;
+}
+//# sourceMappingURL=eq.d.ts.map

package/dist/formula/functions/eq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eq.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/eq.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,SAAc;IACrB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAGhC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IAEvC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG;CAGhC"}

package/dist/formula/functions/eq.js

@@ -0,0 +1,19 @@
+import { BaseFunction as s } from "./__base.js";
+import { eq as a } from "./__utils.js";
+const i = `Returns TRUE if the two specified values are equal, FALSE if they are not.
+This is the same as the '=' operator.`;
+class c extends s {
+  constructor() {
+    super(...arguments), this.example = "EQ(6, 7)", this.description = i, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(e, t) {
+    return a(e, t);
+  }
+}
+export {
+  c as EqFunction
+};
+//# sourceMappingURL=eq.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eq.js","sources":["../../../src/formula/functions/eq.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { eq } from './__utils';\n\nconst description = `Returns TRUE if the two specified values are equal, FALSE if they are not.\nThis is the same as the '=' operator.`;\n\nexport class EqFunction extends BaseFunction {\n  example = 'EQ(6, 7)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'value1', description: 'First value.', acceptedTypes: ['any'] },\n    { name: 'value2', description: 'A value to be compared with value1.', acceptedTypes: ['any'] },\n  ];\n  category: FunctionCategory = 'logical';\n\n  protected main(v1: any, v2: any) {\n    return eq(v1, v2);\n  }\n}\n"],"names":["description","EqFunction","BaseFunction","v1","v2","eq"],"mappings":";;AAGA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAmBC,EAAa;AAAA,EAAtC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,YACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,UAAU,aAAa,gBAAgB,eAAe,CAAC,KAAK,EAAE;AAAA,MACtE,EAAE,MAAM,UAAU,aAAa,uCAAuC,eAAe,CAAC,KAAK,EAAE;AAAA,IAC/F,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAASC,GAAS;AACxB,WAAAC,EAAGF,GAAIC,CAAE;AAAA,EAAA;AAEpB;"}

package/dist/formula/functions/gt.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class GtFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): boolean;
+}
+//# sourceMappingURL=gt.d.ts.map

package/dist/formula/functions/gt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gt.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/gt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,SAAc;IACrB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAGhC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IAEvC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG;CAGhC"}

package/dist/formula/functions/gt.js

@@ -0,0 +1,19 @@
+import { BaseFunction as s } from "./__base.js";
+import { gt as r } from "./__utils.js";
+const i = `Returns TRUE if the first argument is truly greater than the second, FALSE otherwise.
+This is the same as the '>' operator.`;
+class c extends s {
+  constructor() {
+    super(...arguments), this.example = "GT(5, 3)", this.description = i, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(e, t) {
+    return r(e, t);
+  }
+}
+export {
+  c as GtFunction
+};
+//# sourceMappingURL=gt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gt.js","sources":["../../../src/formula/functions/gt.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { gt } from './__utils';\n\nconst description = `Returns TRUE if the first argument is truly greater than the second, FALSE otherwise.\nThis is the same as the '>' operator.`;\n\nexport class GtFunction extends BaseFunction {\n  example = 'GT(5, 3)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'value1', description: 'First value.', acceptedTypes: ['any'] },\n    { name: 'value2', description: 'A value to be compared with value1.', acceptedTypes: ['any'] },\n  ];\n  category: FunctionCategory = 'logical';\n\n  protected main(v1: any, v2: any) {\n    return gt(v1, v2);\n  }\n}\n"],"names":["description","GtFunction","BaseFunction","v1","v2","gt"],"mappings":";;AAGA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAmBC,EAAa;AAAA,EAAtC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,YACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,UAAU,aAAa,gBAAgB,eAAe,CAAC,KAAK,EAAE;AAAA,MACtE,EAAE,MAAM,UAAU,aAAa,uCAAuC,eAAe,CAAC,KAAK,EAAE;AAAA,IAC/F,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAASC,GAAS;AACxB,WAAAC,EAAGF,GAAIC,CAAE;AAAA,EAAA;AAEpB;"}

package/dist/formula/functions/gte.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class GteFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: any, v2: any): boolean;
+}
+//# sourceMappingURL=gte.d.ts.map

package/dist/formula/functions/gte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gte.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/gte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,SAAe;IACtB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAGhC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IAEvC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG;CAGhC"}

package/dist/formula/functions/gte.js

@@ -0,0 +1,19 @@
+import { BaseFunction as s } from "./__base.js";
+import { gte as i } from "./__utils.js";
+const r = `Returns TRUE if the first argument is greater than the second, FALSE otherwise.
+This is the same as the '>=' operator.`;
+class c extends s {
+  constructor() {
+    super(...arguments), this.example = "GTE(5, 3)", this.description = r, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(e, t) {
+    return i(e, t);
+  }
+}
+export {
+  c as GteFunction
+};
+//# sourceMappingURL=gte.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gte.js","sources":["../../../src/formula/functions/gte.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { gte } from './__utils';\n\nconst description = `Returns TRUE if the first argument is greater than the second, FALSE otherwise.\nThis is the same as the '>=' operator.`;\n\nexport class GteFunction extends BaseFunction {\n  example = 'GTE(5, 3)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'value1', description: 'First value.', acceptedTypes: ['any'] },\n    { name: 'value2', description: 'A value to be compared with value1.', acceptedTypes: ['any'] },\n  ];\n  category: FunctionCategory = 'logical';\n\n  protected main(v1: any, v2: any) {\n    return gte(v1, v2);\n  }\n}\n"],"names":["description","GteFunction","BaseFunction","v1","v2","gte"],"mappings":";;AAGA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,aACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,UAAU,aAAa,gBAAgB,eAAe,CAAC,KAAK,EAAE;AAAA,MACtE,EAAE,MAAM,UAAU,aAAa,uCAAuC,eAAe,CAAC,KAAK,EAAE;AAAA,IAC/F,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAASC,GAAS;AACxB,WAAAC,EAAIF,GAAIC,CAAE;AAAA,EAAA;AAErB;"}

package/dist/formula/functions/if.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class IfFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(condition: any, v1: any, v2?: any): any;
+}
+//# sourceMappingURL=if.d.ts.map

package/dist/formula/functions/if.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"if.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/if.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,SAAwC;IAC/C,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAahC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IAEvC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,GAAE,GAAW;CAGxD"}

package/dist/formula/functions/if.js

@@ -0,0 +1,29 @@
+import { BaseFunction as i } from "./__base.js";
+import { ensureBoolean as o } from "./__utils.js";
+const s = `If the logical expression is TRUE, the second argument is returned.
+If FALSE, the third argument is returned.`;
+class d extends i {
+  constructor() {
+    super(...arguments), this.example = 'IF(A2 = "Human", "Hello", "World")', this.description = s, this.defs = [
+      { name: "condition", description: "An expression as a condition", acceptedTypes: ["any"] },
+      {
+        name: "value1",
+        description: "value to be returned if the condition is true.",
+        acceptedTypes: ["any"]
+      },
+      {
+        name: "value2",
+        description: "value to be returned if the condition is false.",
+        optional: !0,
+        acceptedTypes: ["any"]
+      }
+    ], this.category = "logical";
+  }
+  main(e, t, n = !1) {
+    return o(e) ? t : n;
+  }
+}
+export {
+  d as IfFunction
+};
+//# sourceMappingURL=if.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"if.js","sources":["../../../src/formula/functions/if.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureBoolean } from './__utils';\n\nconst description = `If the logical expression is TRUE, the second argument is returned.\nIf FALSE, the third argument is returned.`;\n\nexport class IfFunction extends BaseFunction {\n  example = 'IF(A2 = \"Human\", \"Hello\", \"World\")';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'condition', description: 'An expression as a condition', acceptedTypes: ['any'] },\n    {\n      name: 'value1',\n      description: 'value to be returned if the condition is true.',\n      acceptedTypes: ['any'],\n    },\n    {\n      name: 'value2',\n      description: 'value to be returned if the condition is false.',\n      optional: true,\n      acceptedTypes: ['any'],\n    },\n  ];\n  category: FunctionCategory = 'logical';\n\n  protected main(condition: any, v1: any, v2: any = false) {\n    return ensureBoolean(condition) ? v1 : v2;\n  }\n}\n"],"names":["description","IfFunction","BaseFunction","condition","v1","v2","ensureBoolean"],"mappings":";;AAGA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAmBC,EAAa;AAAA,EAAtC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,sCACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,aAAa,aAAa,gCAAgC,eAAe,CAAC,KAAK,EAAE;AAAA,MACzF;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,KAAK;AAAA,MACvB;AAAA,MACA;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,UAAU;AAAA,QACV,eAAe,CAAC,KAAK;AAAA,MAAA;AAAA,IAEzB,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAAgBC,GAASC,IAAU,IAAO;AAChD,WAAAC,EAAcH,CAAS,IAAIC,IAAKC;AAAA,EAAA;AAE3C;"}

package/dist/formula/functions/iferror.d.ts

@@ -0,0 +1,10 @@
+import { FunctionArgumentDefinition, BaseFunction, FunctionCategory } from './__base';
+export declare class IfErrorFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected broadcastDisabled: boolean;
+    protected main(value: any, valueIfError?: any): any;
+}
+//# sourceMappingURL=iferror.d.ts.map

package/dist/formula/functions/iferror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iferror.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/iferror.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,0BAA0B,EAC1B,YAAY,EACZ,gBAAgB,EAIjB,MAAM,UAAU,CAAC;AAIlB,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,OAAO,SAAqC;IAC5C,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAahC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IACvC,SAAS,CAAC,iBAAiB,UAAQ;IAEnC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,GAAG;CAM9C"}

package/dist/formula/functions/iferror.js

@@ -0,0 +1,28 @@
+import { FormulaError as t } from "../formula-error.js";
+import { BaseFunction as n } from "./__base.js";
+const i = "Returns the first argument if it is not an error value, otherwise returns the second argument if present, or a blank if the second argument is absent.";
+class u extends n {
+  constructor() {
+    super(...arguments), this.example = 'IFERROR(A1, "Error in cell A1")', this.description = i, this.defs = [
+      {
+        name: "value",
+        description: "The value to return if value itself is not an error.",
+        acceptedTypes: ["any"],
+        errorTolerant: !0
+      },
+      {
+        name: "value_if_error",
+        description: "The value the function returns if value is an error.",
+        optional: !0,
+        acceptedTypes: ["any"]
+      }
+    ], this.category = "logical", this.broadcastDisabled = !0;
+  }
+  main(r, e) {
+    return t.is(r) || r instanceof Error ? e : r;
+  }
+}
+export {
+  u as IfErrorFunction
+};
+//# sourceMappingURL=iferror.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iferror.js","sources":["../../../src/formula/functions/iferror.ts"],"sourcesContent":["// DO NOT COPY THIS CODE FOR THE OTHER.\nimport { FormulaError } from '../formula-error';\nimport {\n  FunctionArgumentDefinition,\n  BaseFunction,\n  FunctionCategory,\n  isMatrix,\n  isMultiCell,\n  stripMatrix,\n} from './__base';\n\nconst description = `Returns the first argument if it is not an error value, otherwise returns the second argument if present, or a blank if the second argument is absent.`;\n\nexport class IfErrorFunction extends BaseFunction {\n  example = 'IFERROR(A1, \"Error in cell A1\")';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'The value to return if value itself is not an error.',\n      acceptedTypes: ['any'],\n      errorTolerant: true,\n    },\n    {\n      name: 'value_if_error',\n      description: 'The value the function returns if value is an error.',\n      optional: true,\n      acceptedTypes: ['any'],\n    },\n  ];\n  category: FunctionCategory = 'logical';\n  protected broadcastDisabled = true;\n\n  protected main(value: any, valueIfError?: any) {\n    if (FormulaError.is(value) || value instanceof Error) {\n      return valueIfError;\n    }\n    return value;\n  }\n}\n"],"names":["description","IfErrorFunction","BaseFunction","value","valueIfError","FormulaError"],"mappings":";;AAWA,MAAMA,IAAc;AAEb,MAAMC,UAAwBC,EAAa;AAAA,EAA3C,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,mCACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,KAAK;AAAA,QACrB,eAAe;AAAA,MACjB;AAAA,MACA;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,UAAU;AAAA,QACV,eAAe,CAAC,KAAK;AAAA,MAAA;AAAA,IAEzB,GAC6B,KAAA,WAAA,WAC7B,KAAU,oBAAoB;AAAA,EAAA;AAAA,EAEpB,KAAKG,GAAYC,GAAoB;AAC7C,WAAIC,EAAa,GAAGF,CAAK,KAAKA,aAAiB,QACtCC,IAEFD;AAAA,EAAA;AAEX;"}