@gridsheet/functions 3.0.0-rc.2

package/dist/math/index.js

@@ -0,0 +1,1019 @@
+import { BaseFunction as o, FormulaError as u, ensureNumber as h, Table as f, solveTable as v, conditionArg as g, ensureString as b, eachMatrix as l, stripTable as w, check as y, createBooleanMask as M } from "@gridsheet/react-core";
+const T = "Returns the result of the modulo operation.";
+class A extends o {
+  constructor() {
+    super(...arguments), this.example = "MOD(10, 4)", this.description = T, 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.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  validate(e) {
+    if (e.length !== 2)
+      throw new u("#N/A", "Number of arguments for MOD is incorrect.");
+    const t = e.map((n) => h(n));
+    if (t[1] === 0)
+      throw new u("#DIV/0!", "The second argument must be non-zero.");
+    return t;
+  }
+  main(e, t) {
+    return (e % t + t) % t;
+  }
+}
+const N = "Returns the positive square root of a positive number.";
+class R extends o {
+  constructor() {
+    super(...arguments), this.example = "SQRT(9)", this.description = N, this.defs = [
+      {
+        name: "value",
+        description: "A number for which the positive square root is to be found.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (e < 0)
+      throw new u("NUM!", "First argument must be positive.");
+    return Math.sqrt(e);
+  }
+}
+const F = "Returns the product of a series of numbers.";
+class S extends o {
+  constructor() {
+    super(...arguments), this.example = "PRODUCT(2,3,4)", this.description = F, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to multiply.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  validate(e) {
+    const t = [];
+    return e.forEach((n) => {
+      if (n instanceof f) {
+        t.push(
+          ...v({ table: n }).reduce((r, s) => r.concat(s)).filter((r) => typeof r == "number")
+        );
+        return;
+      }
+      t.push(h(n));
+    }), t;
+  }
+  main(...e) {
+    return e.reduce((t, n) => t * n);
+  }
+}
+const U = "Round a number to the specified number of decimal places according to standard rules.";
+class E extends o {
+  constructor() {
+    super(...arguments), this.example = "ROUND(99.44,1)", this.description = U, this.defs = [
+      {
+        name: "value",
+        description: "A number to be rounded.",
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "digit",
+        description: "The number of decimal places after rounding.",
+        acceptedTypes: ["number"],
+        optional: !0
+      }
+    ], this.category = "math";
+  }
+  main(e, t = 0) {
+    const n = Math.pow(10, t);
+    return Math.round(e * n) / n;
+  }
+}
+const $ = "Round down a number to the specified number of decimal places according to standard rules.";
+class q extends o {
+  constructor() {
+    super(...arguments), this.example = "ROUNDDOWN(99.44,1)", this.description = $, this.defs = [
+      {
+        name: "value",
+        description: "A number to be rounded down.",
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "digit",
+        description: "The number of decimal places after rounding.",
+        acceptedTypes: ["number"],
+        optional: !0
+      }
+    ], this.category = "math";
+  }
+  main(e, t = 0) {
+    const n = Math.pow(10, t);
+    return Math.floor(e * n) / n;
+  }
+}
+const C = "Round up a number to the specified number of decimal places according to standard rules.";
+class I extends o {
+  constructor() {
+    super(...arguments), this.example = "ROUNDUP(99.44,1)", this.description = C, this.defs = [
+      {
+        name: "value",
+        description: "A number to be rounded up.",
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "digit",
+        description: "The number of decimal places after rounding.",
+        acceptedTypes: ["number"],
+        optional: !0
+      }
+    ], this.category = "math";
+  }
+  main(e, t = 0) {
+    const n = Math.pow(10, t);
+    return Math.ceil(e * n) / n;
+  }
+}
+const k = "Returns the logarithm of a number whose base is the specified number.";
+class D extends o {
+  constructor() {
+    super(...arguments), this.example = "LOG(128, 2)", this.description = k, this.defs = [
+      {
+        name: "value",
+        description: "The value for the logarithm of the specified number as base.",
+        acceptedTypes: ["number"]
+      },
+      { name: "base", description: "An exponent to power the base.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e, t) {
+    if (e <= 0)
+      throw new u("NUM!", "value must be greater than 0");
+    if (t <= 1)
+      throw new u("NUM!", "base must be greater than 1");
+    return Math.log2(e) / Math.log2(t);
+  }
+}
+const O = "Returns the logarithm of 10";
+class L extends o {
+  constructor() {
+    super(...arguments), this.example = "LOG10(100)", this.description = O, this.defs = [
+      {
+        name: "value",
+        description: "The value for the logarithm of 10",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (e <= 0)
+      throw new u("NUM!", "value must be greater than 0");
+    return Math.log10(e);
+  }
+}
+const P = "Returns the logarithm of e";
+class V extends o {
+  constructor() {
+    super(...arguments), this.example = "LN(100)", this.description = P, this.defs = [
+      {
+        name: "value",
+        description: "The value for the logarithm of e",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (e <= 0)
+      throw new u("NUM!", "value must be greater than 0");
+    return Math.log(e);
+  }
+}
+const B = "Returns the power of a number whose base is the Euler number e.";
+class _ extends o {
+  constructor() {
+    super(...arguments), this.example = "EXP(2)", this.description = B, this.defs = [
+      {
+        name: "exponent",
+        description: "It is an exponent of power with e as the base.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  validate(e) {
+    if (e.length !== 1)
+      throw new u("#N/A", "Number of arguments for EXP is incorrect.");
+    return [h(e[0])];
+  }
+  main(e) {
+    return Math.exp(e);
+  }
+}
+const z = "Returns the value of Pi.";
+class j extends o {
+  constructor() {
+    super(...arguments), this.example = "PI()", this.description = z, this.defs = [], this.category = "math";
+  }
+  main() {
+    return Math.PI;
+  }
+}
+const G = "Converts an angle value in degrees to radians.";
+class Q extends o {
+  constructor() {
+    super(...arguments), this.example = "RADIANS(180)", this.description = G, this.defs = [
+      {
+        name: "angle",
+        description: "An angle in degrees that you want to convert to radians.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    return e / 180 * Math.PI;
+  }
+}
+const X = "Returns the sin of the angle specified in radians.";
+class W extends o {
+  constructor() {
+    super(...arguments), this.example = "SIN(PI()/2)", this.description = X, this.defs = [
+      {
+        name: "angle",
+        description: "An angle in radians, at which you want the sin.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    return Math.sin(e);
+  }
+}
+const Y = "Returns the cos of the angle specified in radians.";
+class H extends o {
+  constructor() {
+    super(...arguments), this.example = "COS(PI())", this.description = Y, this.defs = [
+      {
+        name: "angle",
+        description: "An angle in radians, at which you want the cos.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    return Math.cos(e);
+  }
+}
+const J = "Returns the tan of the angle specified in radians.";
+class K extends o {
+  constructor() {
+    super(...arguments), this.example = "TAN(PI()/4)", this.description = J, this.defs = [
+      {
+        name: "angle",
+        description: "An angle in radians, at which you want the tan.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    return Math.tan(e);
+  }
+}
+const Z = "Returns the inverse sin of the value in radians.";
+class ee extends o {
+  constructor() {
+    super(...arguments), this.example = "ASIN(1)", this.description = Z, this.defs = [
+      {
+        name: "value",
+        description: "A value for the inverse sin between -1 and 1.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (-1 > e || e > 1)
+      throw new u("#NUM!", "value must be between -1 and 1");
+    return Math.asin(e);
+  }
+}
+const te = "Returns the inverse cos of the value in radians.";
+class ne extends o {
+  constructor() {
+    super(...arguments), this.example = "ACOS(0)", this.description = te, this.defs = [
+      {
+        name: "value",
+        description: "A value for the inverse cos between -1 and 1.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (-1 > e || e > 1)
+      throw new u("#NUM!", "value must be between -1 and 1");
+    return Math.acos(e);
+  }
+}
+const se = "Returns the inverse tan of the value in radians.";
+class re extends o {
+  constructor() {
+    super(...arguments), this.example = "ATAN(1)", this.description = se, this.defs = [
+      {
+        name: "value",
+        description: "A value for the inverse tan.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    return Math.atan(e);
+  }
+}
+const ie = "Returns the angle in radians between the x-axis and a line passing from the origin through a given coordinate point (x, y).";
+class ae extends o {
+  constructor() {
+    super(...arguments), this.example = "ATAN2(4,3)", this.description = ie, this.defs = [
+      {
+        name: "x",
+        description: "x of the point.",
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "y",
+        description: "y of the point.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e, t) {
+    return Math.atan2(e, t);
+  }
+}
+const oe = "Returns a random number between 0 and 1.";
+class ce extends o {
+  constructor() {
+    super(...arguments), this.example = "RAND()", this.description = oe, this.defs = [], this.category = "math";
+  }
+  main() {
+    return Math.random();
+  }
+}
+const ue = "Returns a value interpreted as a percentage, i.e. divides the number by 100.";
+class me extends o {
+  constructor() {
+    super(...arguments), this.example = "UNARY_PERCENT(50)", this.description = ue, this.defs = [
+      {
+        name: "value",
+        description: "A number to be divided by 100.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    return e / 100;
+  }
+}
+const de = "Returns the number with its sign unchanged (unary plus).";
+class he extends o {
+  constructor() {
+    super(...arguments), this.example = "UPLUS(4)", this.description = de, this.defs = [
+      {
+        name: "value",
+        description: "A number to return as-is.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    return e;
+  }
+}
+const pe = "Returns the sum of a series of cells.";
+class le extends o {
+  constructor() {
+    super(...arguments), this.example = 'SUMIF(A1:A10,">20")', this.description = pe, this.defs = [
+      { name: "range", description: "A condition range.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      g,
+      {
+        name: "sum_range",
+        description: "A range to be summarized.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"],
+        optional: !0
+      }
+    ], this.category = "math";
+  }
+  main(e, t, n) {
+    const r = b(t), s = [], a = [];
+    l(
+      e,
+      (c) => {
+        s.push(c);
+      },
+      this.at
+    ), n && l(
+      n,
+      (c) => {
+        a.push(c);
+      },
+      this.at
+    );
+    let m = 0;
+    return s.forEach((c, d) => {
+      const p = w({ value: (n ? a[d] : c) ?? 0 });
+      typeof p == "number" && y(c, r) && (m += p);
+    }), m;
+  }
+}
+const fe = "Returns the sum of a range depending on multiple criteria.";
+class ge extends o {
+  constructor() {
+    super(...arguments), this.example = 'SUMIFS(A1:A10, B1:B10, ">20")', this.description = fe, this.defs = [
+      { name: "sum_range", description: "The range to be summed.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      {
+        name: "range",
+        description: "First condition range.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"],
+        variadic: !0
+      },
+      { ...g, name: "condition", variadic: !0 }
+    ], this.category = "math";
+  }
+  validate(e) {
+    const t = super.validate(e);
+    if ((t.length - 1) % 2 !== 0)
+      throw new u("#N/A", "SUMIFS requires sum_range and at least one range/condition pair.");
+    if (!(t[0] instanceof f))
+      throw new u("#VALUE!", "First argument of SUMIFS must be a range.");
+    const n = t[0].getNumRows(), r = t[0].getNumCols(), s = [], a = [];
+    for (let d = 1; d < t.length; d += 2) {
+      if (!(t[d] instanceof f))
+        throw new u("#VALUE!", `Argument ${d + 1} of SUMIFS must be a range.`);
+      if (t[d].getNumRows() !== n || t[d].getNumCols() !== r)
+        throw new u("#VALUE!", "Array arguments to SUMIFS are of different size.");
+      s.push(t[d]), a.push(b(t[d + 1]));
+    }
+    const m = t[0], c = M(s, a, this.at);
+    return [m, c];
+  }
+  main(e, t) {
+    let n = 0;
+    return l(
+      e,
+      (r, s) => {
+        if (s && t[s.y][s.x]) {
+          const a = w({ value: r ?? 0 });
+          typeof a == "number" && (n += a);
+        }
+      },
+      this.at
+    ), n;
+  }
+}
+const xe = "Returns the count of a series of cells.";
+class be extends o {
+  constructor() {
+    super(...arguments), this.example = 'COUNTIF(A1:A10,">20")', this.description = xe, this.defs = [
+      { name: "range", description: "Target range.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { ...g }
+    ], this.category = "math";
+  }
+  main(e, t) {
+    const n = b(t);
+    let r = 0;
+    return l(
+      e,
+      (s) => {
+        y(s, n) && r++;
+      },
+      this.at
+    ), r;
+  }
+}
+const we = "Returns the count of a range depending on multiple criteria.";
+class ye extends o {
+  constructor() {
+    super(...arguments), this.example = 'COUNTIFS(A1:A10, ">20", B1:B10, "<5")', this.description = we, this.defs = [
+      { name: "range1", description: "First condition range.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { ...g, name: "condition1" },
+      {
+        name: "range2",
+        description: "Additional condition range.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix"],
+        optional: !0,
+        variadic: !0
+      },
+      { ...g, name: "condition2", optional: !0, variadic: !0 }
+    ], this.category = "math";
+  }
+  validate(e) {
+    const t = super.validate(e);
+    if (t.length % 2 !== 0)
+      throw new u("#N/A", "COUNTIFS requires at least one range/condition pair.");
+    const n = t[0] instanceof f ? t[0] : null;
+    let r = 0, s = 0;
+    n && (r = n.getNumRows(), s = n.getNumCols());
+    const a = [], m = [];
+    for (let d = 0; d < t.length; d += 2) {
+      if (!(t[d] instanceof f))
+        throw new u("#VALUE!", `Argument ${d + 1} of COUNTIFS must be a range.`);
+      if (t[d].getNumRows() !== r || t[d].getNumCols() !== s)
+        throw new u("#VALUE!", "Array arguments to COUNTIFS are of different size.");
+      a.push(t[d]), m.push(b(t[d + 1]));
+    }
+    return [M(a, m, this.at)];
+  }
+  main(e) {
+    let t = 0;
+    for (const n of e)
+      for (const r of n)
+        r && t++;
+    return t;
+  }
+}
+const Me = "Returns the factorial of a number.";
+class ve extends o {
+  constructor() {
+    super(...arguments), this.example = "FACT(5)", this.description = Me, this.defs = [
+      {
+        name: "value",
+        description: "A non-negative integer whose factorial will be returned.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (e < 0)
+      throw new u("#NUM!", "FACT requires a non-negative integer.");
+    let t = 1;
+    for (let n = 2; n <= Math.floor(e); n++)
+      t *= n;
+    return t;
+  }
+}
+const Te = "Rounds a number down to the nearest integer that is less than or equal to it.";
+class Ae extends o {
+  constructor() {
+    super(...arguments), this.example = "INT(8.9)", this.description = Te, this.defs = [
+      { name: "value", description: "The value to round down to the nearest integer.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e) {
+    return Math.floor(e);
+  }
+}
+const Ne = "Returns TRUE if the value is even.";
+class Re extends o {
+  constructor() {
+    super(...arguments), this.example = "ISEVEN(4)", this.description = Ne, this.defs = [
+      { name: "value", description: "The value to check for being even.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e) {
+    return Math.floor(Math.abs(e)) % 2 === 0;
+  }
+}
+const Fe = "Returns TRUE if the value is odd.";
+class Se extends o {
+  constructor() {
+    super(...arguments), this.example = "ISODD(3)", this.description = Fe, this.defs = [
+      { name: "value", description: "The value to check for being odd.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e) {
+    return Math.floor(Math.abs(e)) % 2 !== 0;
+  }
+}
+function Ue(i, e) {
+  for (i = Math.abs(Math.floor(i)), e = Math.abs(Math.floor(e)); e; )
+    [i, e] = [e, i % e];
+  return i;
+}
+const Ee = "Returns the least common multiple of one or more integers.";
+class $e extends o {
+  constructor() {
+    super(...arguments), this.example = "LCM(4, 6)", this.description = Ee, this.defs = [
+      { name: "value", description: "Integers (must be >= 1).", acceptedTypes: ["number"], variadic: !0 }
+    ], this.category = "math";
+  }
+  validate(e) {
+    if (e.length === 0)
+      throw new u("#N/A", "LCM requires at least one argument.");
+    return e.map((t) => {
+      const n = Math.floor(h(t));
+      if (n < 1)
+        throw new u("#NUM!", "LCM arguments must be >= 1.");
+      return n;
+    });
+  }
+  main(...e) {
+    return e.reduce((t, n) => t * n / Ue(t, n), 1);
+  }
+}
+const qe = "Rounds a number up to the nearest odd integer.";
+class Ce extends o {
+  constructor() {
+    super(...arguments), this.example = "ODD(2.3)", this.description = qe, this.defs = [
+      { name: "value", description: "The value to round up to the nearest odd integer.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (e === 0)
+      return 1;
+    const t = e > 0 ? 1 : -1;
+    let n = Math.ceil(Math.abs(e));
+    return n % 2 === 0 && n++, t * n;
+  }
+}
+const Ie = "Rounds a number up to the nearest even integer.";
+class ke extends o {
+  constructor() {
+    super(...arguments), this.example = "EVEN(3.1)", this.description = Ie, this.defs = [
+      { name: "value", description: "The value to round up to the nearest even integer.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e) {
+    if (e === 0)
+      return 0;
+    const t = e > 0 ? 1 : -1;
+    let n = Math.ceil(Math.abs(e));
+    return n % 2 !== 0 && n++, t * n;
+  }
+}
+const De = "Returns -1 if the value is negative, 1 if positive, and 0 if zero.";
+class Oe extends o {
+  constructor() {
+    super(...arguments), this.example = "SIGN(-3)", this.description = De, this.defs = [
+      { name: "value", description: "The number to check the sign of.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(e) {
+    return e > 0 ? 1 : e < 0 ? -1 : 0;
+  }
+}
+const Le = "Returns the sum of the squares of a series of numbers or cells.";
+class Pe extends o {
+  constructor() {
+    super(...arguments), this.example = "SUMSQ(A1:A10, 3)", this.description = Le, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to square and sum.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  main(...e) {
+    let t = 0;
+    for (const n of e)
+      l(
+        n,
+        (r) => {
+          const s = h(r, { ignore: !0 });
+          t += s * s;
+        },
+        this.at
+      );
+    return t;
+  }
+}
+const Ve = "Truncates a number to a certain number of significant digits by omitting less significant digits.";
+class Be extends o {
+  constructor() {
+    super(...arguments), this.example = "TRUNC(3.14159, 2)", this.description = Ve, this.defs = [
+      { name: "value", description: "The number to truncate.", acceptedTypes: ["number"] },
+      {
+        name: "places",
+        description: "The number of significant digits to keep. Defaults to 0.",
+        acceptedTypes: ["number"],
+        optional: !0
+      }
+    ], this.category = "math";
+  }
+  main(e, t = 0) {
+    const n = Math.floor(t), r = Math.pow(10, n);
+    return (e >= 0 ? Math.floor : Math.ceil)(e * r) / r;
+  }
+}
+const _e = "Converts a number into a text representation in another base, e.g. base 2 for binary.";
+class ze extends o {
+  constructor() {
+    super(...arguments), this.example = "BASE(255, 16)", this.description = _e, this.defs = [
+      { name: "value", description: "A non-negative integer to convert.", acceptedTypes: ["number"] },
+      { name: "base", description: "The base (radix) to convert into, between 2 and 36.", acceptedTypes: ["number"] },
+      {
+        name: "min_length",
+        description: "Minimum length of the result string (zero-padded).",
+        acceptedTypes: ["number"],
+        optional: !0
+      }
+    ], this.category = "math";
+  }
+  validate(e) {
+    if (e.length < 2 || e.length > 3)
+      throw new u("#N/A", "Number of arguments for BASE is incorrect.");
+    if (e[0] = Math.floor(h(e[0])), e[1] = Math.floor(h(e[1])), e[0] < 0)
+      throw new u("#NUM!", "BASE requires a non-negative integer as value.");
+    if (e[1] < 2 || e[1] > 36)
+      throw new u("#NUM!", "BASE requires a base between 2 and 36.");
+    if (e[2] != null && (e[2] = Math.floor(h(e[2])), e[2] < 0))
+      throw new u("#NUM!", "BASE min_length must be non-negative.");
+    return e;
+  }
+  main(e, t, n) {
+    const r = e.toString(t).toUpperCase();
+    return n != null && r.length < n ? r.padStart(n, "0") : r;
+  }
+}
+const je = `Generates a sequence of numbers in a 2D array.
+Returns a rows × cols array starting at start, incrementing by step.`;
+class Ge extends o {
+  constructor() {
+    super(...arguments), this.autoSpilling = !0, this.example = "SEQUENCE(4, 3, 1, 1)", this.description = je, this.defs = [
+      {
+        name: "rows",
+        description: "The number of rows to return.",
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "columns",
+        description: "The number of columns to return. Defaults to 1.",
+        optional: !0,
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "start",
+        description: "The starting value of the sequence. Defaults to 1.",
+        optional: !0,
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "step",
+        description: "The increment between each value. Defaults to 1.",
+        optional: !0,
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  validate(e) {
+    if (e.length < 1 || e.length > 4)
+      throw new u("#N/A", "Number of arguments for SEQUENCE is incorrect.");
+    if (e[0] = Math.floor(h(e[0])), e[0] < 1)
+      throw new u("#VALUE!", "rows must be at least 1.");
+    if (e.length >= 2 && (e[1] = Math.floor(h(e[1])), e[1] < 1))
+      throw new u("#VALUE!", "columns must be at least 1.");
+    return e.length >= 3 && (e[2] = h(e[2])), e.length >= 4 && (e[3] = h(e[3])), e;
+  }
+  main(e, t = 1, n = 1, r = 1) {
+    const s = [];
+    let a = n;
+    for (let m = 0; m < e; m++) {
+      const c = [];
+      for (let d = 0; d < t; d++)
+        c.push(a), a += r;
+      s.push(c);
+    }
+    return s;
+  }
+}
+class x extends o {
+  constructor() {
+    super(...arguments), this.category = "math";
+  }
+  /** Convert a matrix argument to a 2D number array using eachMatrix. */
+  extractNumberMatrix(e, t) {
+    const n = [];
+    if (l(
+      e,
+      (r, { y: s, x: a }) => {
+        n[s] || (n[s] = []), n[s][a] = h(r);
+      },
+      this.at
+    ), n.length === 0)
+      throw new u("#VALUE!", `${t} must be a non-empty matrix.`);
+    return n;
+  }
+  /** Require the matrix to be square. Throws if not. */
+  requireSquare(e, t) {
+    const n = e.length;
+    if (e.some((r) => r.length !== n))
+      throw new u("#VALUE!", `${t} requires a square matrix.`);
+  }
+}
+const Qe = `Returns the matrix product of two matrices.
+The number of columns in matrix1 must equal the number of rows in matrix2.`;
+class Xe extends x {
+  constructor() {
+    super(...arguments), this.autoSpilling = !0, this.example = "MMULT(A1:B2, C1:D2)", this.description = Qe, this.defs = [
+      { name: "matrix1", description: "First matrix.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { name: "matrix2", description: "Second matrix.", takesMatrix: !0, acceptedTypes: ["matrix"] }
+    ];
+  }
+  validate(e) {
+    if (e.length !== 2)
+      throw new u("#N/A", "MMULT requires exactly 2 arguments.");
+    const t = this.extractNumberMatrix(e[0], "matrix1"), n = this.extractNumberMatrix(e[1], "matrix2"), r = t[0].length, s = n.length;
+    if (r !== s)
+      throw new u(
+        "#VALUE!",
+        `MMULT: number of columns in matrix1 (${r}) must equal number of rows in matrix2 (${s}).`
+      );
+    return [t, n];
+  }
+  main(e, t) {
+    const n = e.length, r = e[0].length, s = t[0].length, a = [];
+    for (let m = 0; m < n; m++) {
+      a[m] = [];
+      for (let c = 0; c < s; c++) {
+        let d = 0;
+        for (let p = 0; p < r; p++)
+          d += e[m][p] * t[p][c];
+        a[m][c] = d;
+      }
+    }
+    return a;
+  }
+}
+const We = `Returns the transpose of a matrix.
+Rows and columns of the input array are swapped.`;
+class Ye extends x {
+  constructor() {
+    super(...arguments), this.autoSpilling = !0, this.example = "TRANSPOSE(A1:C3)", this.description = We, this.defs = [
+      { name: "matrix", description: "The matrix to transpose.", takesMatrix: !0, acceptedTypes: ["matrix"] }
+    ];
+  }
+  validate(e) {
+    if (e.length !== 1)
+      throw new u("#N/A", "TRANSPOSE requires exactly 1 argument.");
+    return [this.extractNumberMatrix(e[0], "matrix")];
+  }
+  main(e) {
+    const t = e.length, n = e[0].length, r = [];
+    for (let s = 0; s < n; s++) {
+      r[s] = [];
+      for (let a = 0; a < t; a++)
+        r[s][a] = e[a][s];
+    }
+    return r;
+  }
+}
+const He = `Returns the inverse of a square matrix.
+The matrix must be square and non-singular (determinant ≠ 0).`;
+class Je extends x {
+  constructor() {
+    super(...arguments), this.autoSpilling = !0, this.example = "MINVERSE(A1:C3)", this.description = He, this.defs = [
+      { name: "matrix", description: "A square numeric matrix.", takesMatrix: !0, acceptedTypes: ["matrix"] }
+    ];
+  }
+  validate(e) {
+    if (e.length !== 1)
+      throw new u("#N/A", "MINVERSE requires exactly 1 argument.");
+    const t = this.extractNumberMatrix(e[0], "matrix");
+    this.requireSquare(t, "MINVERSE");
+    const n = this.invertMatrix(t);
+    if (n === null)
+      throw new u("#NUM!", "MINVERSE: matrix is singular and cannot be inverted.");
+    return [n];
+  }
+  main(e) {
+    return e;
+  }
+  invertMatrix(e) {
+    const t = e.length, n = e.map((r, s) => [...r, ...Array.from({ length: t }, (a, m) => s === m ? 1 : 0)]);
+    for (let r = 0; r < t; r++) {
+      let s = -1, a = 0;
+      for (let c = r; c < t; c++)
+        Math.abs(n[c][r]) > a && (a = Math.abs(n[c][r]), s = c);
+      if (s === -1 || Math.abs(n[s][r]) < 1e-10)
+        return null;
+      [n[r], n[s]] = [n[s], n[r]];
+      const m = n[r][r];
+      for (let c = 0; c < 2 * t; c++)
+        n[r][c] /= m;
+      for (let c = 0; c < t; c++) {
+        if (c === r)
+          continue;
+        const d = n[c][r];
+        for (let p = 0; p < 2 * t; p++)
+          n[c][p] -= d * n[r][p];
+      }
+    }
+    return n.map((r) => r.slice(t));
+  }
+}
+const Ke = "Returns the determinant of a square matrix.";
+class Ze extends x {
+  constructor() {
+    super(...arguments), this.example = "MDETERM(A1:C3)", this.description = Ke, this.defs = [
+      { name: "matrix", description: "A square numeric matrix.", takesMatrix: !0, acceptedTypes: ["matrix"] }
+    ];
+  }
+  validate(e) {
+    if (e.length !== 1)
+      throw new u("#N/A", "MDETERM requires exactly 1 argument.");
+    const t = this.extractNumberMatrix(e[0], "matrix");
+    return this.requireSquare(t, "MDETERM"), [t];
+  }
+  main(e) {
+    return this.determinant(e);
+  }
+  determinant(e) {
+    const t = e.length, n = e.map((s) => [...s]);
+    let r = 1;
+    for (let s = 0; s < t; s++) {
+      let a = s;
+      for (let m = s + 1; m < t; m++)
+        Math.abs(n[m][s]) > Math.abs(n[a][s]) && (a = m);
+      if (a !== s && ([n[s], n[a]] = [n[a], n[s]], r *= -1), Math.abs(n[s][s]) < 1e-10)
+        return 0;
+      r *= n[s][s];
+      for (let m = s + 1; m < t; m++) {
+        const c = n[m][s] / n[s][s];
+        for (let d = s; d < t; d++)
+          n[m][d] -= c * n[s][d];
+      }
+    }
+    return r;
+  }
+}
+const et = `Returns the sum of the products of corresponding array elements.
+All arrays must have the same dimensions.`;
+class tt extends x {
+  constructor() {
+    super(...arguments), this.example = "SUMPRODUCT(A1:A3, B1:B3)", this.description = et, this.defs = [
+      { name: "array1", description: "First array.", takesMatrix: !0, acceptedTypes: ["matrix"] },
+      { name: "array2", description: "Additional arrays.", takesMatrix: !0, acceptedTypes: ["matrix"], variadic: !0 }
+    ];
+  }
+  validate(e) {
+    if (e.length < 1)
+      throw new u("#N/A", "SUMPRODUCT requires at least 1 argument.");
+    const t = e.map((s, a) => this.extractNumberMatrix(s, `array${a + 1}`)), n = t[0].length, r = t[0][0].length;
+    for (let s = 1; s < t.length; s++)
+      if (t[s].length !== n || t[s][0].length !== r)
+        throw new u("#VALUE!", "SUMPRODUCT: all arrays must have the same dimensions.");
+    return [t];
+  }
+  main(e) {
+    const t = e[0].length, n = e[0][0].length;
+    let r = 0;
+    for (let s = 0; s < t; s++)
+      for (let a = 0; a < n; a++) {
+        let m = 1;
+        for (const c of e)
+          m *= c[s][a];
+        r += m;
+      }
+    return r;
+  }
+}
+const st = {
+  mod: A,
+  sqrt: R,
+  product: S,
+  round: E,
+  rounddown: q,
+  roundup: I,
+  log: D,
+  log10: L,
+  ln: V,
+  exp: _,
+  pi: j,
+  radians: Q,
+  sin: W,
+  cos: H,
+  tan: K,
+  asin: ee,
+  acos: ne,
+  atan: re,
+  atan2: ae,
+  rand: ce,
+  unary_percent: me,
+  uplus: he,
+  sumif: le,
+  sumifs: ge,
+  countif: be,
+  countifs: ye,
+  fact: ve,
+  int: Ae,
+  iseven: Re,
+  isodd: Se,
+  lcm: $e,
+  odd: Ce,
+  even: ke,
+  sign: Oe,
+  sumsq: Pe,
+  trunc: Be,
+  base: ze,
+  sequence: Ge,
+  mmult: Xe,
+  transpose: Ye,
+  minverse: Je,
+  mdeterm: Ze,
+  sumproduct: tt
+};
+export {
+  st as default,
+  st as mathFunctions
+};