@gridsheet/core 3.0.0-rc.10

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"len.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/len.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAKtF,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,SAAa;IACpB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAMhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG;CAGzB"}

package/dist/formula/functions/len.js

@@ -0,0 +1,21 @@
+import { BaseFunction as e } from "./__base.js";
+import { ensureString as n } from "./__utils.js";
+const r = "Returns the length of a string.";
+class c extends e {
+  constructor() {
+    super(...arguments), this.example = "LEN(A2)", this.description = r, this.defs = [
+      {
+        name: "text",
+        description: "A text to be returned the length.",
+        acceptedTypes: ["string", "number"]
+      }
+    ], this.category = "text";
+  }
+  main(t) {
+    return n(t).length;
+  }
+}
+export {
+  c as LenFunction
+};
+//# sourceMappingURL=len.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"len.js","sources":["../../../src/formula/functions/len.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureString } from './__utils';\n\nconst description = `Returns the length of a string.`;\n\nexport class LenFunction extends BaseFunction {\n  example = 'LEN(A2)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'text',\n      description: 'A text to be returned the length.',\n      acceptedTypes: ['string', 'number'],\n    },\n  ];\n  category: FunctionCategory = 'text';\n\n  protected main(text: any) {\n    return ensureString(text).length;\n  }\n}\n"],"names":["description","LenFunction","BaseFunction","text","ensureString"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,WACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,QAAQ;AAAA,MAAA;AAAA,IAEtC,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAAW;AACjB,WAAAC,EAAaD,CAAI,EAAE;AAAA,EAAA;AAE9B;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"lt.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/lt.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/lt.js

@@ -0,0 +1,19 @@
+import { BaseFunction as s } from "./__base.js";
+import { lt as i } from "./__utils.js";
+const r = `Returns TRUE if the first argument is truely less than the second argument, FALSE otherwise.
+This is the same as the '<' operator.`;
+class c extends s {
+  constructor() {
+    super(...arguments), this.example = "LT(3, 6)", 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 LtFunction
+};
+//# sourceMappingURL=lt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lt.js","sources":["../../../src/formula/functions/lt.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { lt } from './__utils';\n\nconst description = `Returns TRUE if the first argument is truely less than the second argument, FALSE otherwise.\nThis is the same as the '<' operator.`;\n\nexport class LtFunction extends BaseFunction {\n  example = 'LT(3, 6)';\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 lt(v1, v2);\n  }\n}\n"],"names":["description","LtFunction","BaseFunction","v1","v2","lt"],"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/lte.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"lte.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/lte.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/lte.js

@@ -0,0 +1,19 @@
+import { BaseFunction as s } from "./__base.js";
+import { lte as i } from "./__utils.js";
+const a = `Returns TRUE if the first argument is less than the second argument, FALSE otherwise.
+This is the same as the '<=' operator.`;
+class c extends s {
+  constructor() {
+    super(...arguments), this.example = "LTE(3, 6)", this.description = a, 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 LteFunction
+};
+//# sourceMappingURL=lte.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lte.js","sources":["../../../src/formula/functions/lte.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { lte } from './__utils';\n\nconst description = `Returns TRUE if the first argument is less than the second argument, FALSE otherwise.\nThis is the same as the '<=' operator.`;\n\nexport class LteFunction extends BaseFunction {\n  example = 'LTE(3, 6)';\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 lte(v1, v2);\n  }\n}\n"],"names":["description","LteFunction","BaseFunction","v1","v2","lte"],"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/max.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"max.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/max.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAY,MAAM,UAAU,CAAC;AAKhG,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,SAAuB;IAC9B,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/max.js

@@ -0,0 +1,37 @@
+import { BaseFunction as a, isMatrix as n } from "./__base.js";
+import { eachMatrix as o, ensureNumber as u } from "./__utils.js";
+const m = "Returns the max in a series of numbers or cells.";
+class x extends a {
+  constructor() {
+    super(...arguments), this.example = "MAX(A2:A100, 101)", this.description = m, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to find max from.",
+        acceptedTypes: ["number", "matrix"],
+        takesMatrix: !0,
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  main(...i) {
+    let t = -1 / 0, r = !1;
+    return i.forEach((s) => {
+      if (n(s))
+        o(
+          s,
+          (e) => {
+            typeof e == "number" && (e > t && (t = e), r = !0);
+          },
+          this.at
+        );
+      else {
+        const e = u(s);
+        e > t && (t = e), r = !0;
+      }
+    }), r ? t : 0;
+  }
+}
+export {
+  x as MaxFunction
+};
+//# sourceMappingURL=max.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"max.js","sources":["../../../src/formula/functions/max.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition, isMatrix } from './__base';\nimport { ensureNumber, eachMatrix } from './__utils';\n\nconst description = `Returns the max in a series of numbers or cells.`;\n\nexport class MaxFunction extends BaseFunction {\n  example = 'MAX(A2:A100, 101)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'Numbers or ranges to find max from.',\n      acceptedTypes: ['number', 'matrix'],\n      takesMatrix: true,\n      variadic: true,\n    },\n  ];\n  category: FunctionCategory = 'statistics';\n\n  protected main(...values: any[]) {\n    let max = -Infinity;\n    let hasValues = false;\n    values.forEach((val) => {\n      if (isMatrix(val)) {\n        eachMatrix(\n          val,\n          (v) => {\n            if (typeof v === 'number') {\n              if (v > max) {\n                max = v;\n              }\n              hasValues = true;\n            }\n          },\n          this.at,\n        );\n      } else {\n        const num = ensureNumber(val);\n        if (num > max) {\n          max = num;\n        }\n        hasValues = true;\n      }\n    });\n    return hasValues ? max : 0;\n  }\n}\n"],"names":["description","MaxFunction","BaseFunction","values","max","hasValues","val","isMatrix","eachMatrix","v","num","ensureNumber"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,qBACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,QAAQ;AAAA,QAClC,aAAa;AAAA,QACb,UAAU;AAAA,MAAA;AAAA,IAEd,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,QAAQG,GAAe;AAC/B,QAAIC,IAAM,QACNC,IAAY;AACT,WAAAF,EAAA,QAAQ,CAACG,MAAQ;AAClB,UAAAC,EAASD,CAAG;AACd,QAAAE;AAAA,UACEF;AAAA,UACA,CAACG,MAAM;AACD,YAAA,OAAOA,KAAM,aACXA,IAAIL,MACAA,IAAAK,IAEIJ,IAAA;AAAA,UAEhB;AAAA,UACA,KAAK;AAAA,QACP;AAAA,WACK;AACC,cAAAK,IAAMC,EAAaL,CAAG;AAC5B,QAAII,IAAMN,MACFA,IAAAM,IAEIL,IAAA;AAAA,MAAA;AAAA,IACd,CACD,GACMA,IAAYD,IAAM;AAAA,EAAA;AAE7B;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"min.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/min.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAY,MAAM,UAAU,CAAC;AAKhG,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,SAAuB;IAC9B,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/min.js

@@ -0,0 +1,37 @@
+import { BaseFunction as n, isMatrix as a } from "./__base.js";
+import { eachMatrix as o, ensureNumber as u } from "./__utils.js";
+const m = "Returns the min in a series of numbers or cells.";
+class h extends n {
+  constructor() {
+    super(...arguments), this.example = "MIN(A2:A100, 101)", this.description = m, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to find min from.",
+        acceptedTypes: ["number", "matrix"],
+        takesMatrix: !0,
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  main(...s) {
+    let t = 1 / 0, i = !1;
+    return s.forEach((r) => {
+      if (a(r))
+        o(
+          r,
+          (e) => {
+            typeof e == "number" && (e < t && (t = e), i = !0);
+          },
+          this.at
+        );
+      else {
+        const e = u(r);
+        e < t && (t = e), i = !0;
+      }
+    }), i ? t : 0;
+  }
+}
+export {
+  h as MinFunction
+};
+//# sourceMappingURL=min.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"min.js","sources":["../../../src/formula/functions/min.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition, isMatrix } from './__base';\nimport { ensureNumber, eachMatrix } from './__utils';\n\nconst description = `Returns the min in a series of numbers or cells.`;\n\nexport class MinFunction extends BaseFunction {\n  example = 'MIN(A2:A100, 101)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'Numbers or ranges to find min from.',\n      acceptedTypes: ['number', 'matrix'],\n      takesMatrix: true,\n      variadic: true,\n    },\n  ];\n  category: FunctionCategory = 'statistics';\n\n  protected main(...values: any[]) {\n    let min = Infinity;\n    let hasValues = false;\n    values.forEach((val) => {\n      if (isMatrix(val)) {\n        eachMatrix(\n          val,\n          (v) => {\n            if (typeof v === 'number') {\n              if (v < min) {\n                min = v;\n              }\n              hasValues = true;\n            }\n          },\n          this.at,\n        );\n      } else {\n        const num = ensureNumber(val);\n        if (num < min) {\n          min = num;\n        }\n        hasValues = true;\n      }\n    });\n    return hasValues ? min : 0;\n  }\n}\n"],"names":["description","MinFunction","BaseFunction","values","min","hasValues","val","isMatrix","eachMatrix","v","num","ensureNumber"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,qBACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,QAAQ;AAAA,QAClC,aAAa;AAAA,QACb,UAAU;AAAA,MAAA;AAAA,IAEd,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,QAAQG,GAAe;AAC/B,QAAIC,IAAM,OACNC,IAAY;AACT,WAAAF,EAAA,QAAQ,CAACG,MAAQ;AAClB,UAAAC,EAASD,CAAG;AACd,QAAAE;AAAA,UACEF;AAAA,UACA,CAACG,MAAM;AACD,YAAA,OAAOA,KAAM,aACXA,IAAIL,MACAA,IAAAK,IAEIJ,IAAA;AAAA,UAEhB;AAAA,UACA,KAAK;AAAA,QACP;AAAA,WACK;AACC,cAAAK,IAAMC,EAAaL,CAAG;AAC5B,QAAII,IAAMN,MACFA,IAAAM,IAEIL,IAAA;AAAA,MAAA;AAAA,IACd,CACD,GACMA,IAAYD,IAAM;AAAA,EAAA;AAE7B;"}

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

@@ -0,0 +1,10 @@
+import { Time } from '../../lib/time';
+import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';
+export declare class MinusFunction extends BaseFunction {
+    example: string;
+    description: string;
+    defs: FunctionArgumentDefinition[];
+    category: FunctionCategory;
+    protected main(v1: number | Date | Time, v2: number | Date | Time): number | Time | Date;
+}
+//# sourceMappingURL=minus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"minus.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/minus.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAOtF,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,SAAiB;IACxB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAOhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;CAwBlE"}

package/dist/formula/functions/minus.js

@@ -0,0 +1,41 @@
+import s from "dayjs";
+import { FormulaError as i } from "../formula-error.js";
+import { Time as r } from "../../lib/time.js";
+import { BaseFunction as a } from "./__base.js";
+import { ensureNumber as n } from "./__utils.js";
+import { SECONDS_IN_DAY as o } from "../../constants.js";
+const m = `Returns the difference of two numbers.
+This is the same as the '-' operator.`;
+class y extends a {
+  constructor() {
+    super(...arguments), this.example = "MINUS(8, 3)", this.description = m, this.defs = [
+      { name: "value1", description: "A number that will be subtracted.", acceptedTypes: ["number", "date", "time"] },
+      {
+        name: "value2",
+        description: "A number that will subtract from value1.",
+        acceptedTypes: ["number", "date", "time"]
+      }
+    ], this.category = "math";
+  }
+  main(e, t) {
+    if (typeof e == "number" && typeof t == "number")
+      return e - t;
+    if (e instanceof Date && t instanceof Date)
+      return r.fromDates(e, t);
+    if (e instanceof Date && r.is(t))
+      return r.ensure(t).sub(e);
+    if (r.is(e) && t instanceof Date)
+      return r.ensure(e).sub(t);
+    if (e instanceof Date && typeof t == "number")
+      return s(e).subtract(t * o, "second").toDate();
+    try {
+      return n(e, { alternative: 0 }) - n(t, { alternative: 0 });
+    } catch {
+      throw new i("#VALUE!", "Mismatched types for minuend or subtrahend.");
+    }
+  }
+}
+export {
+  y as MinusFunction
+};
+//# sourceMappingURL=minus.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"minus.js","sources":["../../../src/formula/functions/minus.ts"],"sourcesContent":["import dayjs from 'dayjs';\n\nimport { FormulaError } from '../formula-error';\nimport { Time } from '../../lib/time';\nimport { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureNumber } from './__utils';\nimport { SECONDS_IN_DAY } from '../../constants';\n\nconst description = `Returns the difference of two numbers.\nThis is the same as the '-' operator.`;\n\nexport class MinusFunction extends BaseFunction {\n  example = 'MINUS(8, 3)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'value1', description: 'A number that will be subtracted.', acceptedTypes: ['number', 'date', 'time'] },\n    {\n      name: 'value2',\n      description: 'A number that will subtract from value1.',\n      acceptedTypes: ['number', 'date', 'time'],\n    },\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 && v2 instanceof Date) {\n      return Time.fromDates(v1, v2);\n    }\n    if (v1 instanceof Date && Time.is(v2)) {\n      return Time.ensure(v2).sub(v1);\n    }\n    if (Time.is(v1) && v2 instanceof Date) {\n      return Time.ensure(v1).sub(v2);\n    }\n    if (v1 instanceof Date && typeof v2 === 'number') {\n      return dayjs(v1)\n        .subtract(v2 * 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 minuend or subtrahend.');\n    }\n  }\n}\n"],"names":["description","MinusFunction","BaseFunction","v1","v2","Time","dayjs","SECONDS_IN_DAY","ensureNumber","FormulaError"],"mappings":";;;;;;AAQA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAsBC,EAAa;AAAA,EAAzC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,eACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,UAAU,aAAa,qCAAqC,eAAe,CAAC,UAAU,QAAQ,MAAM,EAAE;AAAA,MAC9G;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,UAAU,QAAQ,MAAM;AAAA,MAAA;AAAA,IAE5C,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAA0BC,GAA0B;AACjE,QAAI,OAAOD,KAAO,YAAY,OAAOC,KAAO;AAC1C,aAAOD,IAAKC;AAEV,QAAAD,aAAc,QAAQC,aAAc;AAC/B,aAAAC,EAAK,UAAUF,GAAIC,CAAE;AAE9B,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,SAASC,IAAKG,GAAgB,QAAQ,EACtC,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,6CAA6C;AAAA,IAAA;AAAA,EACjF;AAEJ;"}

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

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

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

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

package/dist/formula/functions/multiply.js

@@ -0,0 +1,19 @@
+import { BaseFunction as s } from "./__base.js";
+import { ensureNumber as e } from "./__utils.js";
+const o = `Returns the product of two numbers.
+This is the same as the '*' operator.`;
+class a extends s {
+  constructor() {
+    super(...arguments), this.example = "MULTIPLY(6, 7)", this.description = o, this.defs = [
+      { name: "factor1", description: "First factor.", acceptedTypes: ["number"] },
+      { name: "factor2", description: "Second factor.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(t, r) {
+    return e(t) * e(r);
+  }
+}
+export {
+  a as MultiplyFunction
+};
+//# sourceMappingURL=multiply.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"multiply.js","sources":["../../../src/formula/functions/multiply.ts"],"sourcesContent":["import { FormulaError } from '../formula-error';\nimport { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureNumber } from './__utils';\n\nconst description = `Returns the product of two numbers.\nThis is the same as the '*' operator.`;\n\nexport class MultiplyFunction extends BaseFunction {\n  example = 'MULTIPLY(6, 7)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'factor1', description: 'First factor.', acceptedTypes: ['number'] },\n    { name: 'factor2', description: 'Second factor.', acceptedTypes: ['number'] },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected main(v1: any, v2: any) {\n    return ensureNumber(v1) * ensureNumber(v2);\n  }\n}\n"],"names":["description","MultiplyFunction","BaseFunction","v1","v2","ensureNumber"],"mappings":";;AAIA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAyBC,EAAa;AAAA,EAA5C,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,kBACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,WAAW,aAAa,iBAAiB,eAAe,CAAC,QAAQ,EAAE;AAAA,MAC3E,EAAE,MAAM,WAAW,aAAa,kBAAkB,eAAe,CAAC,QAAQ,EAAE;AAAA,IAC9E,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/ne.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ne.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/ne.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,MAAM,EAAE,EAAE,EAAE,MAAM;CAGtC"}

package/dist/formula/functions/ne.js

@@ -0,0 +1,19 @@
+import { BaseFunction as s } from "./__base.js";
+import { ne as a } from "./__utils.js";
+const i = `Returns TRUE if the two specified values are not equal, FALSE if they are.
+This is the same as the '<>' operator.`;
+class c extends s {
+  constructor() {
+    super(...arguments), this.example = "NE(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 NeFunction
+};
+//# sourceMappingURL=ne.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ne.js","sources":["../../../src/formula/functions/ne.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ne } from './__utils';\n\nconst description = `Returns TRUE if the two specified values are not equal, FALSE if they are.\nThis is the same as the '<>' operator.`;\n\nexport class NeFunction extends BaseFunction {\n  example = 'NE(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: number, v2: number) {\n    return ne(v1, v2);\n  }\n}\n"],"names":["description","NeFunction","BaseFunction","v1","v2","ne"],"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,GAAYC,GAAY;AAC9B,WAAAC,EAAGF,GAAIC,CAAE;AAAA,EAAA;AAEpB;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"not.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/not.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,CAMhC;IACF,QAAQ,EAAE,gBAAgB,CAAa;IAEvC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG;CAGvB"}

package/dist/formula/functions/not.js

@@ -0,0 +1,22 @@
+import { BaseFunction as o } from "./__base.js";
+import { ensureBoolean as s } from "./__utils.js";
+const n = `Returns the inverse of the Boolean; if TRUE, NOT returns FALSE.
+If FALSE, NOT returns TRUE.`;
+class a extends o {
+  constructor() {
+    super(...arguments), this.example = "NOT(TRUE)", this.description = n, this.defs = [
+      {
+        name: "logical expression",
+        description: "A logical expression as a boolean.",
+        acceptedTypes: ["boolean", "number"]
+      }
+    ], this.category = "logical";
+  }
+  main(e) {
+    return !s(e);
+  }
+}
+export {
+  a as NotFunction
+};
+//# sourceMappingURL=not.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"not.js","sources":["../../../src/formula/functions/not.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureBoolean } from './__utils';\n\nconst description = `Returns the inverse of the Boolean; if TRUE, NOT returns FALSE.\nIf FALSE, NOT returns TRUE.`;\n\nexport class NotFunction extends BaseFunction {\n  example = 'NOT(TRUE)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'logical expression',\n      description: 'A logical expression as a boolean.',\n      acceptedTypes: ['boolean', 'number'],\n    },\n  ];\n  category: FunctionCategory = 'logical';\n\n  protected main(v1: any) {\n    return !ensureBoolean(v1);\n  }\n}\n"],"names":["description","NotFunction","BaseFunction","v1","ensureBoolean"],"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;AAAA,QACE,MAAM;AAAA,QACN,aAAa;AAAA,QACb,eAAe,CAAC,WAAW,QAAQ;AAAA,MAAA;AAAA,IAEvC,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAAS;AACf,WAAA,CAACC,EAAcD,CAAE;AAAA,EAAA;AAE5B;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"now.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/now.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAItF,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,SAAW;IAClB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAAM;IACxC,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI;CAGf"}

package/dist/formula/functions/now.js

@@ -0,0 +1,14 @@
+import { BaseFunction as t } from "./__base.js";
+const e = "Returns a serial value corresponding to the current date and time.";
+class s extends t {
+  constructor() {
+    super(...arguments), this.example = "NOW()", this.description = e, this.defs = [], this.category = "time";
+  }
+  main() {
+    return /* @__PURE__ */ new Date();
+  }
+}
+export {
+  s as NowFunction
+};
+//# sourceMappingURL=now.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"now.js","sources":["../../../src/formula/functions/now.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\n\nconst description = `Returns a serial value corresponding to the current date and time.`;\n\nexport class NowFunction extends BaseFunction {\n  example = 'NOW()';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [];\n  category: FunctionCategory = 'time';\n\n  protected main() {\n    return new Date();\n  }\n}\n"],"names":["description","NowFunction","BaseFunction"],"mappings":";AAEA,MAAMA,IAAc;AAEb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,SACI,KAAA,cAAAF,GACd,KAAA,OAAqC,CAAC,GACT,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,OAAO;AACf,+BAAW,KAAK;AAAA,EAAA;AAEpB;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"or.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/or.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAMtF,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,SAAoB;IAC3B,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/or.js

@@ -0,0 +1,23 @@
+import { BaseFunction as t } from "./__base.js";
+import { ensureBoolean as i } from "./__utils.js";
+const a = `Returns TRUE if any argument is logically true.
+Returns FALSE if all arguments are logically false.`;
+class l extends t {
+  constructor() {
+    super(...arguments), this.example = "OR(A1=1, A2=2)", this.description = a, 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 OrFunction
+};
+//# sourceMappingURL=or.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"or.js","sources":["../../../src/formula/functions/or.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureBoolean } from './__utils';\n\nconst description = `Returns TRUE if any argument is logically true.\nReturns FALSE if all arguments are logically false.`;\n\nexport class OrFunction extends BaseFunction {\n  example = 'OR(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","OrFunction","BaseFunction","values","v","ensureBoolean","a","b"],"mappings":";;AAGA,MAAMA,IAAc;AAAA;AAGb,MAAMC,UAAmBC,EAAa;AAAA,EAAtC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,kBACI,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/power.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"power.d.ts","sourceRoot":"","sources":["../../../src/formula/functions/power.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAKtF,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,SAAkB;IACzB,WAAW,SAAe;IAC1B,IAAI,EAAE,0BAA0B,EAAE,CAGhC;IACF,QAAQ,EAAE,gBAAgB,CAAU;IAEpC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG;CAGxC"}

package/dist/formula/functions/power.js

@@ -0,0 +1,18 @@
+import { BaseFunction as r } from "./__base.js";
+import { ensureNumber as e } from "./__utils.js";
+const o = "Returns a number multiplied by an exponent.";
+class a extends r {
+  constructor() {
+    super(...arguments), this.example = "POWER(4,0.5)", this.description = o, this.defs = [
+      { name: "base", description: "A number to be multiplied by an exponent.", acceptedTypes: ["number"] },
+      { name: "exponent", description: "An exponent to power the base.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(t, n) {
+    return Math.pow(e(t), e(n));
+  }
+}
+export {
+  a as PowerFunction
+};
+//# sourceMappingURL=power.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"power.js","sources":["../../../src/formula/functions/power.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureNumber } from './__utils';\n\nconst description = `Returns a number multiplied by an exponent.`;\n\nexport class PowerFunction extends BaseFunction {\n  example = 'POWER(4,0.5)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    { name: 'base', description: 'A number to be multiplied by an exponent.', acceptedTypes: ['number'] },\n    { name: 'exponent', description: 'An exponent to power the base.', acceptedTypes: ['number'] },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected main(base: any, exponent: any) {\n    return Math.pow(ensureNumber(base), ensureNumber(exponent));\n  }\n}\n"],"names":["description","PowerFunction","BaseFunction","base","exponent","ensureNumber"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAsBC,EAAa;AAAA,EAAzC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,gBACI,KAAA,cAAAF,GACuB,KAAA,OAAA;AAAA,MACnC,EAAE,MAAM,QAAQ,aAAa,6CAA6C,eAAe,CAAC,QAAQ,EAAE;AAAA,MACpG,EAAE,MAAM,YAAY,aAAa,kCAAkC,eAAe,CAAC,QAAQ,EAAE;AAAA,IAC/F,GAC6B,KAAA,WAAA;AAAA,EAAA;AAAA,EAEnB,KAAKG,GAAWC,GAAe;AACvC,WAAO,KAAK,IAAIC,EAAaF,CAAI,GAAGE,EAAaD,CAAQ,CAAC;AAAA,EAAA;AAE9D;"}

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

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

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

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

package/dist/formula/functions/sum.js

@@ -0,0 +1,34 @@
+import { BaseFunction as i } from "./__base.js";
+import { eachMatrix as n, ensureNumber as o } from "./__utils.js";
+const a = "Returns the sum of a series of numbers or cells.";
+class h extends i {
+  constructor() {
+    super(...arguments), this.example = "SUM(A2:A100, 101)", this.description = a, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to sum.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  main(...e) {
+    if (e.length === 0)
+      return 0;
+    let r = 0;
+    return e.forEach((t) => {
+      n(
+        t,
+        (s) => {
+          r += o(s, { ignore: !0 });
+        },
+        this.at
+      );
+    }), r;
+  }
+}
+export {
+  h as SumFunction
+};
+//# sourceMappingURL=sum.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sum.js","sources":["../../../src/formula/functions/sum.ts"],"sourcesContent":["import { BaseFunction, FunctionCategory, FunctionArgumentDefinition } from './__base';\nimport { ensureNumber, eachMatrix } from './__utils';\n\nconst description = `Returns the sum of a series of numbers or cells.`;\n\nexport class SumFunction extends BaseFunction {\n  example = 'SUM(A2:A100, 101)';\n  description = description;\n  defs: FunctionArgumentDefinition[] = [\n    {\n      name: 'value',\n      description: 'Numbers or ranges to sum.',\n      takesMatrix: true,\n      acceptedTypes: ['number', 'matrix'],\n      variadic: true,\n    },\n  ];\n  category: FunctionCategory = 'math';\n\n  protected main(...values: any[]) {\n    if (values.length === 0) {\n      return 0;\n    }\n    let sum = 0;\n    values.forEach((val) => {\n      eachMatrix(\n        val,\n        (v) => {\n          sum += ensureNumber(v, { ignore: true });\n        },\n        this.at,\n      );\n    });\n    return sum;\n  }\n}\n"],"names":["description","SumFunction","BaseFunction","values","sum","val","eachMatrix","v","ensureNumber"],"mappings":";;AAGA,MAAMA,IAAc;AAEb,MAAMC,UAAoBC,EAAa;AAAA,EAAvC,cAAA;AAAA,UAAA,GAAA,SAAA,GACK,KAAA,UAAA,qBACI,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;AAC3B,QAAAA,EAAO,WAAW;AACb,aAAA;AAET,QAAIC,IAAM;AACH,WAAAD,EAAA,QAAQ,CAACE,MAAQ;AACtB,MAAAC;AAAA,QACED;AAAA,QACA,CAACE,MAAM;AACL,UAAAH,KAAOI,EAAaD,GAAG,EAAE,QAAQ,IAAM;AAAA,QACzC;AAAA,QACA,KAAK;AAAA,MACP;AAAA,IAAA,CACD,GACMH;AAAA,EAAA;AAEX;"}