@gridsheet/functions 3.0.0-rc.10

package/dist/math/index.js

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