@limitlesspc/std 0.20.2

package/dist/chunk-C2DS6YRJ.js

@@ -0,0 +1,1664 @@
+import {
+  random
+} from "./chunk-EWSJTMH2.js";
+import {
+  chunk,
+  collect,
+  filter,
+  map,
+  range,
+  tee
+} from "./chunk-WBSY6KRH.js";
+import {
+  pipe,
+  reverseCurry
+} from "./chunk-MG5VQSTV.js";
+
+// src/math/stats.ts
+function min(iter) {
+  let min2 = Number.POSITIVE_INFINITY;
+  for (const value of iter) {
+    if (value < min2) {
+      min2 = value;
+    }
+  }
+  return min2;
+}
+function max(iter) {
+  let max2 = Number.NEGATIVE_INFINITY;
+  for (const value of iter) {
+    if (value > max2) {
+      max2 = value;
+    }
+  }
+  return max2;
+}
+function minmax(iter) {
+  let min2 = Number.POSITIVE_INFINITY;
+  let max2 = Number.NEGATIVE_INFINITY;
+  for (const value of iter) {
+    if (value < min2) {
+      min2 = value;
+    }
+    if (value > max2) {
+      max2 = value;
+    }
+  }
+  return [min2, max2];
+}
+function sum(iter) {
+  let total = 0;
+  for (const value of iter) {
+    total += value;
+  }
+  return total;
+}
+function product(iter) {
+  let total = 1;
+  for (const value of iter) {
+    total *= value;
+  }
+  return total;
+}
+function avg(iter) {
+  let total = 0;
+  let count = 0;
+  for (const value of iter) {
+    total += value;
+    count++;
+  }
+  return total / count;
+}
+function median(array) {
+  const { length } = array;
+  if (!length) {
+    return 0;
+  }
+  const sorted = [...array].sort((a, b) => a - b);
+  if (length % 2) {
+    return sorted[length / 2];
+  }
+  return (sorted[length / 2 - 1] + sorted[length / 2]) / 2;
+}
+function mode(iter) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const n of iter) {
+    const count = counts.get(n) || 0;
+    counts.set(n, count + 1);
+  }
+  const maxCount = max(counts.values());
+  return pipe(
+    counts,
+    filter(([_, count]) => count === maxCount),
+    map(([n]) => n),
+    collect
+  );
+}
+function variance(iter) {
+  const [a, b] = tee(iter);
+  const m = avg(a);
+  return avg(
+    map(b, (n) => {
+      const d = n - m;
+      return d * d;
+    })
+  );
+}
+function stddev(iter) {
+  return Math.sqrt(variance(iter));
+}
+function meanAbsDev(iter) {
+  const [a, b] = tee(iter);
+  const m = avg(a);
+  return avg(map(b, (n) => n - m));
+}
+
+// src/math/funcs.ts
+function isNumber(x) {
+  return typeof x === "number" && !Number.isNaN(x);
+}
+function isReal(x) {
+  return isNumber(x) && Number.isFinite(x);
+}
+function isInteger(x) {
+  return Number.isInteger(x);
+}
+function roundToMultiple(x, n) {
+  return Math.floor(x / n) * n;
+}
+function roundToEven(x) {
+  return roundToMultiple(x, 2);
+}
+function norm(x, min2, max2) {
+  return (x - min2) / (max2 - min2);
+}
+function lerp(min2, max2, norm2) {
+  return min2 + (max2 - min2) * norm2;
+}
+function map2(x, fromMin, fromMax, toMin, toMax) {
+  return lerp(toMin, toMax, norm(x, fromMin, fromMax));
+}
+function step(x, edge = 0) {
+  return x < edge ? 0 : 1;
+}
+function smoothstep(x, min2, max2) {
+  x = clamp(norm(x, min2, max2), 0, 1);
+  return x * x * (3 - 2 * x);
+}
+function smootherstep(x, min2, max2) {
+  x = clamp(norm(x, min2, max2), 0, 1);
+  return x * x * x * (x * (x * 6 - 15) + 10);
+}
+function clamp(n, min2, max2) {
+  return Math.min(Math.max(n, min2), max2);
+}
+function overlap(min1, max1, min2, max2) {
+  [min1, max1] = minmax([min1, max1]);
+  [min2, max2] = minmax([min2, max2]);
+  const range1 = max1 - min1;
+  const range2 = max2 - min2;
+  const range3 = Math.max(max1, max2) - Math.min(min1, min2);
+  return range1 + range2 - range3;
+}
+function closer(x, a, b) {
+  return Math.abs(x - a[0]) < Math.abs(x - b[0]) ? a[1] : b[1];
+}
+function round(n, precision = 0) {
+  const factor = 10 ** precision;
+  return Math.round(n * factor) / factor;
+}
+function floor(n, precision = 0) {
+  const factor = 10 ** precision;
+  return Math.floor(n * factor) / factor;
+}
+function ceil(n, precision = 0) {
+  const factor = 10 ** precision;
+  return Math.ceil(n * factor) / factor;
+}
+function trunc(n, precision = 0) {
+  const factor = 10 ** precision;
+  return Math.trunc(n * factor) / factor;
+}
+function fract(x) {
+  return x - Math.floor(x);
+}
+function closeTo(n, target, precision = 5) {
+  return Math.abs(n - target) < 10 ** -precision;
+}
+function factorial(n) {
+  let total = 1;
+  for (let i = n; i > 1; i--) {
+    total *= i;
+  }
+  return total;
+}
+function log(base, x) {
+  return Math.log(x) / Math.log(base);
+}
+var ln = Math.log;
+function gcd(a, b) {
+  while (b) {
+    const temp = b;
+    b = a % b;
+    a = temp;
+  }
+  return a;
+}
+function fibonacci(n) {
+  let a = 0;
+  let b = 1;
+  for (let i = 0; i < n; i++) {
+    const temp = a;
+    a = b;
+    b += temp;
+  }
+  return a;
+}
+var celsius = (fahrenheit2) => (fahrenheit2 - 32) * (5 / 9);
+var fahrenheit = (celsius2) => celsius2 * (9 / 5) + 32;
+function lineOfBestFit(points) {
+  const xs = points.map((p) => p.x);
+  const ys = points.map((p) => p.y);
+  const meanX = avg(xs);
+  const meanY = avg(ys);
+  let n = 0;
+  let den = 0;
+  for (let i = 0; i < points.length; i++) {
+    const x = xs[i];
+    const y = ys[i];
+    n += (x - meanX) * (y - meanY);
+    den += (x - meanX) ** 2;
+  }
+  const m = n / den;
+  const b = meanY - m * meanX;
+  return [m, b];
+}
+function permutations(n, k) {
+  if (k > n) {
+    return 0;
+  }
+  return factorial(n) / factorial(n - k);
+}
+function combinations(n, k) {
+  if (k > n) {
+    return 0;
+  }
+  return permutations(n, k) / factorial(k);
+}
+function dot(a, b) {
+  const iter1 = a[Symbol.iterator]();
+  const iter2 = b[Symbol.iterator]();
+  let total = 0;
+  while (true) {
+    const result1 = iter1.next();
+    const result2 = iter2.next();
+    if (result1.done && result2.done) {
+      break;
+    }
+    total += (result1.value || 0) * (result2.value || 0);
+  }
+  return total;
+}
+
+// src/iter/repeat.ts
+var repeat = reverseCurry(function* repeat2(iter, n) {
+  const values = [];
+  for (const i of range(n)) {
+    if (i) {
+      for (const value of values) {
+        yield value;
+      }
+    } else {
+      for (const value of iter) {
+        yield value;
+        values.push(value);
+      }
+    }
+  }
+});
+
+// src/math/matrix/mat.ts
+var Mat = class _Mat extends Float32Array {
+  rows;
+  constructor(rows, cols = 0) {
+    if (typeof rows === "number") {
+      super(repeat([0], rows * cols));
+      this.rows = rows;
+    } else {
+      super(rows.flat());
+      this.rows = rows.length;
+    }
+  }
+  get cols() {
+    return this.length / this.rows;
+  }
+  toString() {
+    return `mat [
+  ${pipe(this, chunk(this.cols), collect).map((row) => row.join(" ")).join("\n  ")}
+]`;
+  }
+  copy() {
+    const m = mat(this.rows, this.cols);
+    m.set(this);
+    return m;
+  }
+  static random(rows, cols) {
+    const m = mat(rows, cols);
+    for (let i = 0, { length } = this; i < length; i++) {
+      m[i] = random(-1, 1);
+    }
+    return m;
+  }
+  eq(m, precision) {
+    if (this.rows !== m.rows || this.cols !== m.cols) {
+      return false;
+    }
+    for (let i = 0, { length } = this; i < length; i++) {
+      const a = this[i];
+      const b = m[i];
+      if (!closeTo(a, b, precision)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  add(m) {
+    if (this.rows !== m.rows || this.cols !== m.cols) {
+      return this;
+    }
+    for (let i = 0, { length } = this; i < length; i++) {
+      this[i] += m[i] || 0;
+    }
+    return this;
+  }
+  static add(m1, m2) {
+    return m1.copy().add(m2);
+  }
+  sub(m) {
+    if (this.rows !== m.rows || this.cols !== m.cols) {
+      return this;
+    }
+    for (let i = 0, { length } = this; i < length; i++) {
+      this[i] -= m[i] || 0;
+    }
+    return this;
+  }
+  static sub(m1, m2) {
+    return m1.copy().sub(m2);
+  }
+  mul(m) {
+    this.set(_Mat.mul(this, m));
+    return this;
+  }
+  static mul(m1, m2) {
+    if (typeof m2 === "number") {
+      const { rows: rows2, cols: cols2 } = m1;
+      const ans2 = mat(rows2, cols2);
+      for (let i = 0, { length } = m1; i < length; i++) {
+        ans2[i] = (m1[i] ?? 1) * m2;
+      }
+      return ans2;
+    }
+    const ans = mat(m1.rows, m2.cols);
+    const { rows, cols } = ans;
+    for (let i = 0; i < rows; i++) {
+      for (let j = 0; j < cols; j++) {
+        let sum2 = 0;
+        for (let k = 0; k < m1.cols; k++) {
+          sum2 += (m1[i * m1.cols + k] ?? 1) * (m2[k * m2.cols + j] ?? 1);
+        }
+        ans[i * cols + j] = sum2;
+      }
+    }
+    return ans;
+  }
+  div(m) {
+    return this.mul(1 / m);
+  }
+  static transpose(m) {
+    const { rows, cols } = m;
+    const ans = mat(cols, rows);
+    for (let i = 0, { length } = this; i < length; i++) {
+      for (let j = 0; j < cols; j++) {
+        ans[j * cols + i] = m[i * cols + j] || 0;
+      }
+    }
+    return ans;
+  }
+};
+function mat(rows, cols = 1) {
+  if (typeof rows === "number") {
+    return new Mat(rows, cols);
+  }
+  return new Mat(rows);
+}
+
+// src/math/matrix/mat2.ts
+var Mat2 = class _Mat2 extends Float32Array {
+  static BYTE_LENGTH = 4 * Float32Array.BYTES_PER_ELEMENT;
+  constructor(matrix = [1, 0, 0, 1]) {
+    super(matrix);
+  }
+  toString() {
+    const [a, b, c, d] = this;
+    return `mat2 [
+  ${a} ${b}
+  ${c} ${d}
+]`;
+  }
+  copy() {
+    return mat2(this);
+  }
+  identity() {
+    this.set([1, 0, 0, 1]);
+    return this;
+  }
+  eq(m, precision) {
+    for (let i = 0; i < 4; i++) {
+      const a = this[i];
+      const b = m[i];
+      if (!closeTo(a, b, precision)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  add(m) {
+    for (let i = 0; i < 4; i++) {
+      this[i] += m[i];
+    }
+    return this;
+  }
+  static add(m1, m2) {
+    return m1.copy().add(m2);
+  }
+  sub(m) {
+    for (let i = 0; i < 4; i++) {
+      this[i] -= m[i];
+    }
+    return this;
+  }
+  static sub(m1, m2) {
+    return m1.copy().sub(m2);
+  }
+  mul(m) {
+    this.set(_Mat2.mul(this, m));
+    return this;
+  }
+  static mul(m1, m2) {
+    if (typeof m2 === "number") {
+      const ans = mat2();
+      for (let i = 0; i < 4; i++) {
+        ans[i] *= m2;
+      }
+      return ans;
+    }
+    const [a0 = 0, a1 = 0, a2 = 0, a3 = 0] = m1;
+    const [b0 = 0, b1 = 0, b2 = 0, b3 = 0] = m2;
+    return mat2([
+      a0 * b0 + a1 * b2,
+      a0 * b1 + a1 * b3,
+      a2 * b0 + a3 * b2,
+      a2 * b1 + a3 * b3
+    ]);
+  }
+  div(m) {
+    return this.mul(1 / m);
+  }
+  transpose() {
+    const [, b = 0, c = 0] = this;
+    [this[2], this[1]] = [b, c];
+    return this;
+  }
+  det() {
+    const [a = 0, b = 0, c = 0, d = 0] = this;
+    return a * d - b * c;
+  }
+  adj() {
+    const [a = 0, b = 0, c = 0, d = 0] = this;
+    return mat2([d, -b, -c, a]);
+  }
+  inv() {
+    return this.adj().div(this.det());
+  }
+};
+function mat2(matrix) {
+  return new Mat2(matrix);
+}
+
+// src/math/matrix/mat3.ts
+var Mat3 = class _Mat3 extends Float32Array {
+  static BYTE_LENGTH = 9 * Float32Array.BYTES_PER_ELEMENT;
+  constructor(matrix = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
+    super(matrix);
+  }
+  toString() {
+    const [a, b, c, d, e, f, g, h, i] = this;
+    return `mat3 [
+  ${a} ${b} ${c}
+  ${d} ${e} ${f}
+  ${g} ${h} ${i}
+]`;
+  }
+  copy() {
+    return mat3(this);
+  }
+  identity() {
+    this.set([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+    return this;
+  }
+  eq(m, precision) {
+    for (let i = 0; i < 9; i++) {
+      const a = this[i];
+      const b = m[i];
+      if (!closeTo(a, b, precision)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  add(m) {
+    for (let i = 0; i < 9; i++) {
+      this[i] += m[i];
+    }
+    return this;
+  }
+  static add(m1, m2) {
+    return m1.copy().add(m2);
+  }
+  sub(m) {
+    for (let i = 0; i < 9; i++) {
+      this[i] -= m[i];
+    }
+    return this;
+  }
+  static sub(m1, m2) {
+    return m1.copy().sub(m2);
+  }
+  mul(m) {
+    this.set(_Mat3.mul(this, m));
+    return this;
+  }
+  static mul(m1, m2) {
+    if (typeof m2 === "number") {
+      const ans = mat3(m1);
+      for (let i = 0; i < 9; i++) {
+        ans[i] *= m2;
+      }
+      return ans;
+    }
+    const [
+      a0 = 0,
+      a1 = 0,
+      a2 = 0,
+      a3 = 0,
+      a4 = 0,
+      a5 = 0,
+      a6 = 0,
+      a7 = 0,
+      a8 = 0
+    ] = m1;
+    const [
+      b0 = 0,
+      b1 = 0,
+      b2 = 0,
+      b3 = 0,
+      b4 = 0,
+      b5 = 0,
+      b6 = 0,
+      b7 = 0,
+      b8 = 0
+    ] = m2;
+    return mat3([
+      a0 * b0 + a1 * b3 + a2 * b6,
+      a0 * b1 + a1 * b4 + a2 * b7,
+      a0 * b2 + a1 * b5 + a2 * b8,
+      a3 * b0 + a4 * b3 + a5 * b6,
+      a3 * b1 + a4 * b4 + a5 * b7,
+      a3 * b2 + a4 * b5 + a5 * b8,
+      a6 * b0 + a7 * b3 + a8 * b6,
+      a6 * b1 + a7 * b4 + a8 * b7,
+      a6 * b2 + a7 * b5 + a8 * b8
+    ]);
+  }
+  div(m) {
+    return this.mul(1 / m);
+  }
+  transpose() {
+    const [, b = 0, c = 0, d = 0, , f = 0, g = 0, h = 0] = this;
+    [this[3], this[1]] = [b, d];
+    [this[6], this[2]] = [c, g];
+    [this[7], this[5]] = [f, h];
+    return this;
+  }
+  det() {
+    const [a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0] = this;
+    return a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+  }
+  adj() {
+    const [a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0] = this;
+    return mat3([
+      e * i - f * h,
+      -(d * i - f * g),
+      d * h - e * g,
+      -(b * i - c * h),
+      a * i - c * g,
+      -(a * h - b * g),
+      b * f - c * e,
+      -(a * f - c * d),
+      a * e - b * d
+    ]).transpose();
+  }
+  inv() {
+    return this.adj().div(this.det());
+  }
+};
+function mat3(matrix) {
+  return new Mat3(matrix);
+}
+
+// src/math/matrix/mat4.ts
+var Mat4 = class _Mat4 extends Float32Array {
+  constructor(matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]) {
+    super(matrix);
+  }
+  toString() {
+    const [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = this;
+    return `mat4 [
+  ${a} ${b} ${c} ${d}
+  ${e} ${f} ${g} ${h}
+  ${i} ${j} ${k} ${l}
+  ${m} ${n} ${o} ${p}
+]`;
+  }
+  copy() {
+    return mat4(this);
+  }
+  eq(m, precision) {
+    for (let i = 0; i < 16; i++) {
+      const a = this[i];
+      const b = m[i];
+      if (!closeTo(a, b, precision)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  add(m) {
+    for (let i = 0; i < 16; i++) {
+      this[i] += m[i];
+    }
+    return this;
+  }
+  static add(m1, m2) {
+    return m1.copy().add(m2);
+  }
+  sub(m) {
+    for (let i = 0; i < 16; i++) {
+      this[i] -= m[i];
+    }
+    return this;
+  }
+  static sub(m1, m2) {
+    return m1.copy().sub(m2);
+  }
+  mul(m) {
+    this.set(_Mat4.mul(this, m));
+    return this;
+  }
+  static mul(m1, m2) {
+    if (typeof m2 === "number") {
+      const ans = mat4();
+      for (let i = 0; i < 16; i++) {
+        ans[i] *= m2;
+      }
+      return ans;
+    }
+    const [
+      a0 = 0,
+      a1 = 0,
+      a2 = 0,
+      a3 = 0,
+      a4 = 0,
+      a5 = 0,
+      a6 = 0,
+      a7 = 0,
+      a8 = 0,
+      a9 = 0,
+      a10 = 0,
+      a11 = 0,
+      a12 = 0,
+      a13 = 0,
+      a14 = 0,
+      a15 = 0
+    ] = m1;
+    const [
+      b0 = 0,
+      b1 = 0,
+      b2 = 0,
+      b3 = 0,
+      b4 = 0,
+      b5 = 0,
+      b6 = 0,
+      b7 = 0,
+      b8 = 0,
+      b9 = 0,
+      b10 = 0,
+      b11 = 0,
+      b12 = 0,
+      b13 = 0,
+      b14 = 0,
+      b15 = 0
+    ] = m2;
+    return mat4([
+      a0 * b0 + a1 * b4 + a2 * b8 + a3 * b12,
+      a0 * b1 + a1 * b5 + a2 * b9 + a3 * b13,
+      a0 * b2 + a1 * b6 + a2 * b10 + a3 * b14,
+      a0 * b3 + a1 * b7 + a2 * b11 + a3 * b15,
+      a4 * b0 + a5 * b4 + a6 * b8 + a7 * b12,
+      a4 * b1 + a5 * b5 + a6 * b9 + a7 * b13,
+      a4 * b2 + a5 * b6 + a6 * b10 + a7 * b14,
+      a4 * b3 + a5 * b7 + a6 * b11 + a7 * b15,
+      a8 * b0 + a9 * b4 + a10 * b8 + a11 * b12,
+      a8 * b1 + a9 * b5 + a10 * b9 + a11 * b13,
+      a8 * b2 + a9 * b6 + a10 * b10 + a11 * b14,
+      a8 * b3 + a9 * b7 + a10 * b11 + a11 * b15,
+      a12 * b0 + a13 * b4 + a14 * b8 + a15 * b12,
+      a12 * b1 + a13 * b5 + a14 * b9 + a15 * b13,
+      a12 * b2 + a13 * b6 + a14 * b10 + a15 * b14,
+      a12 * b3 + a13 * b7 + a14 * b11 + a15 * b15
+    ]);
+  }
+  div(m) {
+    return this.mul(1 / m);
+  }
+  transpose() {
+    const [
+      ,
+      b = 0,
+      c = 0,
+      d = 0,
+      e = 0,
+      ,
+      g = 0,
+      h = 0,
+      i = 0,
+      j = 0,
+      ,
+      l = 0,
+      m = 0,
+      n = 0,
+      o = 0
+    ] = this;
+    [this[4], this[1]] = [b, e];
+    [this[8], this[2]] = [c, i];
+    [this[12], this[3]] = [d, m];
+    [this[9], this[6]] = [g, j];
+    [this[13], this[7]] = [h, n];
+    [this[14], this[11]] = [l, o];
+    return this;
+  }
+  det() {
+    const [
+      a = 0,
+      b = 0,
+      c = 0,
+      d = 0,
+      e = 0,
+      f = 0,
+      g = 0,
+      h = 0,
+      i = 0,
+      j = 0,
+      k = 0,
+      l = 0,
+      m = 0,
+      n = 0,
+      o = 0,
+      p = 0
+    ] = this;
+    return a * mat3([f, g, h, j, k, l, n, o, p]).det() - b * mat3([e, g, h, i, k, l, m, o, p]).det() + c * mat3([e, f, h, i, j, l, m, n, p]).det() - d * mat3([e, f, g, i, j, k, m, n, o]).det();
+  }
+  adj() {
+    const [
+      a = 0,
+      b = 0,
+      c = 0,
+      d = 0,
+      e = 0,
+      f = 0,
+      g = 0,
+      h = 0,
+      i = 0,
+      j = 0,
+      k = 0,
+      l = 0,
+      m = 0,
+      n = 0,
+      o = 0,
+      p = 0
+    ] = this;
+    return mat4([
+      mat3([f, g, h, j, k, l, n, o, p]).det(),
+      -mat3([e, g, h, i, k, l, m, o, p]).det(),
+      mat3([e, f, h, i, j, l, m, n, p]).det(),
+      -mat3([e, f, g, i, j, k, m, n, o]).det(),
+      -mat3([b, c, d, j, k, l, n, o, p]).det(),
+      mat3([a, c, d, i, k, l, m, o, p]).det(),
+      -mat3([a, b, d, i, j, l, m, n, p]).det(),
+      mat3([a, b, c, i, j, k, m, n, o]).det(),
+      mat3([b, c, d, f, g, h, n, o, p]).det(),
+      -mat3([a, c, d, e, g, h, m, o, p]).det(),
+      mat3([a, b, d, e, f, h, m, n, p]).det(),
+      -mat3([a, b, c, e, f, g, m, n, o]).det(),
+      -mat3([b, c, d, f, g, h, j, k, l]).det(),
+      mat3([a, c, d, e, g, h, i, k, l]).det(),
+      -mat3([a, b, d, e, f, h, i, j, l]).det(),
+      mat3([a, b, c, e, f, g, i, j, k]).det()
+    ]).transpose();
+  }
+  inv() {
+    return this.adj().div(this.det());
+  }
+};
+function mat4(matrix) {
+  return new Mat4(matrix);
+}
+
+// src/math/trig.ts
+var DEG2RAD = Math.PI / 180;
+var degrees = (radians2) => radians2 / DEG2RAD;
+var radians = (degrees2) => degrees2 * DEG2RAD;
+
+// src/math/vector/vec2.ts
+var Vec2 = class _Vec2 extends Float32Array {
+  static BYTE_LENGTH = 2 * Float32Array.BYTES_PER_ELEMENT;
+  constructor(x = 0, y) {
+    super([0, 0]);
+    if (typeof x === "number") {
+      this.x = x;
+      this.y = y ?? x;
+    } else {
+      [this[0] = 0, this[1] = 0] = x;
+    }
+  }
+  /* prettier-ignore */
+  get x() {
+    return this[0] || 0;
+  }
+  /* prettier-ignore */
+  set x(value) {
+    this[0] = value;
+  }
+  /* prettier-ignore */
+  get y() {
+    return this[1] || 0;
+  }
+  /* prettier-ignore */
+  set y(value) {
+    this[1] = value;
+  }
+  toString() {
+    const [x, y] = this;
+    return `vec2 <${x}, ${y}>`;
+  }
+  copy() {
+    return vec2(...this);
+  }
+  static random(mag = 1) {
+    return vec2(1, 0).rotate(random(Math.PI * 2)).setMag(mag);
+  }
+  eq(x, y) {
+    if (typeof x === "number") {
+      return this.x === x && this.y === (y ?? x);
+    }
+    return this.x === x[0] && this.y === x[1];
+  }
+  add(x, y) {
+    if (typeof x === "number") {
+      this.x += x;
+      this.y += y ?? x;
+    } else {
+      this.x += x[0];
+      this.y += x[1];
+    }
+    return this;
+  }
+  static add(v1, x, y) {
+    return v1.copy().add(x, y);
+  }
+  sub(x, y) {
+    if (typeof x === "number") {
+      this.x -= x;
+      this.y -= y ?? x;
+    } else {
+      this.x -= x[0];
+      this.y -= x[1];
+    }
+    return this;
+  }
+  static sub(v1, x, y) {
+    return v1.copy().sub(x, y);
+  }
+  mul(x, y) {
+    if (typeof x === "number") {
+      this.x *= x;
+      this.y *= y ?? x;
+    } else {
+      this.x *= x[0];
+      this.y *= x[1];
+    }
+    return this;
+  }
+  static mul(v1, x, y) {
+    return v1.copy().mul(x, y);
+  }
+  div(x, y) {
+    if (typeof x === "number") {
+      this.x *= x;
+      this.y *= y ?? x;
+    } else {
+      this.x *= x[0];
+      this.y *= x[1];
+    }
+    return this;
+  }
+  static div(v1, x, y) {
+    return v1.copy().div(x, y);
+  }
+  static fma(a, b, c) {
+    return vec2(a[0] * b[0] + c[0], a[1] * b[1] + c[1]);
+  }
+  lt(x) {
+    return vec2(this.x < x[0] ? 1 : 0, this.y < x[1] ? 1 : 0);
+  }
+  lte(x) {
+    return vec2(this.x <= x[0] ? 1 : 0, this.y <= x[1] ? 1 : 0);
+  }
+  gt(x) {
+    return vec2(this.x > x[0] ? 1 : 0, this.y > x[1] ? 1 : 0);
+  }
+  gte(x) {
+    return vec2(this.x >= x[0] ? 1 : 0, this.y >= x[1] ? 1 : 0);
+  }
+  mag() {
+    return Math.sqrt(this.magSq());
+  }
+  setMag(n) {
+    return this.normalize().mul(n);
+  }
+  magSq() {
+    const { x, y } = this;
+    return x * x + y * y;
+  }
+  limit(max2) {
+    const maxSq = max2 * max2;
+    const magSq = this.magSq();
+    if (magSq > maxSq) {
+      this.setMag(max2);
+    }
+    return this;
+  }
+  normalize() {
+    const mag = this.mag();
+    if (mag !== 0) {
+      this.div(mag);
+    }
+    return this;
+  }
+  static normalize(v) {
+    return v.copy().normalize();
+  }
+  dist(v) {
+    return Math.sqrt(this.distSq(v));
+  }
+  distSq(v) {
+    return _Vec2.sub(v, this).magSq();
+  }
+  dot(v) {
+    return this.x * v[0] + this.y * v[1];
+  }
+  cross(v) {
+    return this.x * v[1] - this.y * v[0];
+  }
+  lerp(v, norm2) {
+    const { x, y } = this;
+    this.x = lerp(x, v[0], norm2);
+    this.y = lerp(y, v[1], norm2);
+    return this;
+  }
+  static lerp(v1, v2, norm2) {
+    return v1.copy().lerp(v2, norm2);
+  }
+  clamp(min2, max2) {
+    const { x, y } = this;
+    this.x = clamp(x, min2[0], max2[0]);
+    this.y = clamp(y, min2[1], max2[1]);
+    return this;
+  }
+  static clamp(v, min2, max2) {
+    return v.copy().clamp(min2, max2);
+  }
+  perp() {
+    return vec2(this.y, -this.x);
+  }
+  angle() {
+    return Math.atan2(this.y, this.x);
+  }
+  setAngle(a) {
+    const mag = this.mag();
+    this.x = Math.cos(a) * mag;
+    this.y = Math.sin(a) * mag;
+    return this;
+  }
+  static fromAngle(a, mag = 1) {
+    return vec2(mag).setAngle(a);
+  }
+  rotate(angle) {
+    const { x, y } = this;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    this.x = cos * x - sin * y;
+    this.y = sin * x + cos * y;
+    return this;
+  }
+  static rotate(v, angle) {
+    return v.copy().rotate(angle);
+  }
+  rotateAbout(angle, center) {
+    return this.sub(center).rotate(angle).add(center);
+  }
+  reflect(normal) {
+    return this.sub(_Vec2.mul(normal, 2 * this.dot(normal)));
+  }
+  refract(normal, eta) {
+    const dot2 = this.dot(normal);
+    const k = 1 - eta * eta * (1 - dot2 * dot2);
+    if (k < 0) {
+      this.x = this.y = 0;
+      return this;
+    }
+    return this.mul(eta).sub(_Vec2.mul(normal, eta * dot2 + Math.sqrt(k)));
+  }
+};
+function vec2(x, y) {
+  return new Vec2(x, y);
+}
+
+// src/math/vector/vec3.ts
+var Vec3 = class _Vec3 extends Float32Array {
+  static BYTE_LENGTH = 3 * Float32Array.BYTES_PER_ELEMENT;
+  constructor(x = 0, y, z) {
+    super([0, 0, 0]);
+    if (typeof x === "number") {
+      this.x = x;
+      this.y = y ?? x;
+      this.z = z ?? (y === void 0 ? x : 0);
+    } else {
+      [this[0] = 0, this[1] = 0, this[2] = 0] = x;
+    }
+  }
+  /* prettier-ignore */
+  get x() {
+    return this[0] || 0;
+  }
+  /* prettier-ignore */
+  set x(value) {
+    this[0] = value;
+  }
+  /* prettier-ignore */
+  get y() {
+    return this[1] || 0;
+  }
+  /* prettier-ignore */
+  set y(value) {
+    this[1] = value;
+  }
+  /* prettier-ignore */
+  get z() {
+    return this[2] || 0;
+  }
+  /* prettier-ignore */
+  set z(value) {
+    this[2] = value;
+  }
+  /* prettier-ignore */
+  get r() {
+    return this[0] || 0;
+  }
+  /* prettier-ignore */
+  set r(value) {
+    this[0] = value;
+  }
+  /* prettier-ignore */
+  get g() {
+    return this[1] || 0;
+  }
+  /* prettier-ignore */
+  set g(value) {
+    this[1] = value;
+  }
+  /* prettier-ignore */
+  get b() {
+    return this[2] || 0;
+  }
+  /* prettier-ignore */
+  set b(value) {
+    this[2] = value;
+  }
+  toString() {
+    const [x, y, z] = this;
+    return `vec3 <${x}, ${y}, ${z}>`;
+  }
+  copy() {
+    return vec3(...this);
+  }
+  static random(mag = 1) {
+    return vec3(0, 0, 1).rotateX(random(Math.PI * 2)).rotateY(random(Math.PI * 2)).setMag(mag);
+  }
+  eq(x, y, z) {
+    if (typeof x === "number") {
+      return this.x === x && this.y === (y ?? x) && this.z === (z ?? (y === void 0 ? x : 0));
+    }
+    return this.x === x[0] && this.y === x[1] && this.z === x[2];
+  }
+  neg() {
+    return vec3(-this.x, -this.y, -this.z);
+  }
+  add(x, y, z) {
+    if (typeof x === "number") {
+      this.x += x;
+      this.y += y ?? x;
+      this.z += z ?? (y === void 0 ? x : 0);
+    } else {
+      this.x += x[0];
+      this.y += x[1];
+      this.z += x[2];
+    }
+    return this;
+  }
+  static add(v1, x, y, z) {
+    return v1.copy().add(x, y, z);
+  }
+  sub(x, y, z) {
+    if (typeof x === "number") {
+      this.x -= x;
+      this.y -= y ?? x;
+      this.z -= z ?? (y === void 0 ? x : 0);
+    } else {
+      this.x -= x[0];
+      this.y -= x[1];
+      this.z -= x[2];
+    }
+    return this;
+  }
+  static sub(v1, x, y, z) {
+    return v1.copy().sub(x, y, z);
+  }
+  mul(x, y, z) {
+    if (typeof x === "number") {
+      this.x *= x;
+      this.y *= y ?? x;
+      this.z *= z ?? (y === void 0 ? x : 1);
+    } else {
+      this.x *= x[0];
+      this.y *= x[1];
+      this.z *= x[2];
+    }
+    return this;
+  }
+  static mul(v1, x, y, z) {
+    return v1.copy().mul(x, y, z);
+  }
+  div(x, y, z) {
+    if (typeof x === "number") {
+      this.x /= x;
+      this.y /= y ?? x;
+      this.z /= z ?? (y === void 0 ? x : 1);
+    } else {
+      this.x /= x[0];
+      this.y /= x[1];
+      this.z /= x[2];
+    }
+    return this;
+  }
+  static div(v1, x, y, z) {
+    return v1.copy().div(x, y, z);
+  }
+  static fma(a, b, c) {
+    return vec3(a[0] * b[0] + c[0], a[1] * b[1] + c[1], a[2] * b[2] + c[2]);
+  }
+  lt(x) {
+    return vec3(
+      this.x < x[0] ? 1 : 0,
+      this.y < x[1] ? 1 : 0,
+      this.z < x[2] ? 1 : 0
+    );
+  }
+  lte(x) {
+    return vec3(
+      this.x <= x[0] ? 1 : 0,
+      this.y <= x[1] ? 1 : 0,
+      this.z <= x[2] ? 1 : 0
+    );
+  }
+  gt(x) {
+    return vec3(
+      this.x > x[0] ? 1 : 0,
+      this.y > x[1] ? 1 : 0,
+      this.z > x[2] ? 1 : 0
+    );
+  }
+  gte(x) {
+    return vec3(
+      this.x >= x[0] ? 1 : 0,
+      this.y >= x[1] ? 1 : 0,
+      this.z >= x[2] ? 1 : 0
+    );
+  }
+  limit(max2) {
+    const maxSq = max2 * max2;
+    const magSq = this.magSq();
+    if (magSq > maxSq) {
+      this.setMag(max2);
+    }
+    return this;
+  }
+  normalize() {
+    const mag = this.mag();
+    if (mag !== 0) {
+      this.div(mag);
+    }
+    return this;
+  }
+  static normalize(v) {
+    return v.copy().normalize();
+  }
+  mag() {
+    return Math.sqrt(this.magSq());
+  }
+  setMag(n) {
+    return this.normalize().mul(n);
+  }
+  magSq() {
+    const { x, y, z } = this;
+    return x * x + y * y + z * z;
+  }
+  dist(v) {
+    return Math.sqrt(this.distSq(v));
+  }
+  distSq(v) {
+    return _Vec3.sub(v, this).magSq();
+  }
+  dot(v) {
+    const { x, y, z } = this;
+    return x * v[0] + y * v[1] + z * v[2];
+  }
+  cross(v) {
+    const { x, y, z } = this;
+    return vec3(y * v[2] - z * v[1], z * v[0] - x * v[2], x * v[1] - y * v[0]);
+  }
+  lerp(v, norm2) {
+    const { x, y, z } = this;
+    this.x = lerp(x, v[0], norm2);
+    this.y = lerp(y, v[1], norm2);
+    this.z = lerp(z, v[2], norm2);
+    return this;
+  }
+  static lerp(v1, v2, norm2) {
+    return v1.copy().lerp(v2, norm2);
+  }
+  clamp(min2, max2) {
+    const { x, y, z } = this;
+    this.x = clamp(x, min2[0], max2[0]);
+    this.y = clamp(y, min2[1], max2[1]);
+    this.z = clamp(z, min2[2], max2[2]);
+    return this;
+  }
+  static clamp(v, min2, max2) {
+    return v.copy().clamp(min2, max2);
+  }
+  rotateX(angle) {
+    const { y, z } = this;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    this.y = cos * y - sin * z;
+    this.z = sin * y + cos * z;
+    return this;
+  }
+  rotateY(angle) {
+    const { x, z } = this;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    this.x = cos * x + sin * z;
+    this.z = -sin * x + cos * z;
+    return this;
+  }
+  rotateZ(angle) {
+    const { x, y } = this;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    this.x = cos * x - sin * y;
+    this.y = sin * x + cos * y;
+    return this;
+  }
+  reflect(normal) {
+    return this.sub(_Vec3.mul(normal, 2 * this.dot(normal)));
+  }
+  static reflect(v, normal) {
+    return v.copy().reflect(normal);
+  }
+  refract(normal, eta) {
+    const nDot = this.dot(normal);
+    const k = 1 - eta * eta * (1 - nDot * nDot);
+    if (k < 0) {
+      this.x = this.y = this.z = 0;
+      return this;
+    }
+    return this.sub(_Vec3.mul(normal, eta * nDot + Math.sqrt(k)));
+  }
+};
+function vec3(x, y, z) {
+  return new Vec3(x, y, z);
+}
+
+// src/math/vector/vec4.ts
+var Vec4 = class _Vec4 extends Float32Array {
+  static BYTE_LENGTH = 4 * Float32Array.BYTES_PER_ELEMENT;
+  constructor(x = 0, y, z, w) {
+    super([0, 0, 0, 0]);
+    if (typeof x === "number") {
+      this.x = x;
+      this.y = y ?? x;
+      this.z = z ?? (y === void 0 ? x : 0);
+      this.w = w ?? (z === void 0 ? x : 0);
+    } else {
+      [this[0] = 0, this[1] = 0, this[2] = 0, this[3] = 0] = x;
+    }
+  }
+  /* prettier-ignore */
+  get x() {
+    return this[0] || 0;
+  }
+  /* prettier-ignore */
+  set x(value) {
+    this[0] = value;
+  }
+  /* prettier-ignore */
+  get y() {
+    return this[1] || 0;
+  }
+  /* prettier-ignore */
+  set y(value) {
+    this[1] = value;
+  }
+  /* prettier-ignore */
+  get z() {
+    return this[2] || 0;
+  }
+  /* prettier-ignore */
+  set z(value) {
+    this[2] = value;
+  }
+  /* prettier-ignore */
+  get w() {
+    return this[2] || 0;
+  }
+  /* prettier-ignore */
+  set w(value) {
+    this[2] = value;
+  }
+  /* prettier-ignore */
+  get r() {
+    return this[0] || 0;
+  }
+  /* prettier-ignore */
+  set r(value) {
+    this[0] = value;
+  }
+  /* prettier-ignore */
+  get g() {
+    return this[1] || 0;
+  }
+  /* prettier-ignore */
+  set g(value) {
+    this[1] = value;
+  }
+  /* prettier-ignore */
+  get b() {
+    return this[2] || 0;
+  }
+  /* prettier-ignore */
+  set b(value) {
+    this[2] = value;
+  }
+  /* prettier-ignore */
+  get a() {
+    return this[2] || 0;
+  }
+  /* prettier-ignore */
+  set a(value) {
+    this[2] = value;
+  }
+  toString() {
+    const [x, y, z, w] = this;
+    return `vec4 <${x}, ${y}, ${z}, ${w}>`;
+  }
+  copy() {
+    return vec4(...this);
+  }
+  eq(x, y, z, w) {
+    if (typeof x === "number") {
+      return this.x === x && this.y === (y ?? x) && this.z === (z ?? (y === void 0 ? x : 0)) && this.w === (w ?? (z === void 0 ? x : 0));
+    }
+    return this.x === x[0] && this.y === x[1] && this.z === x[2] && this.w === x[3];
+  }
+  add(x, y, z, w) {
+    if (typeof x === "number") {
+      this.x += x;
+      this.y += y ?? x;
+      this.z += z ?? (y === void 0 ? x : 0);
+      this.w += w ?? (z === void 0 ? x : 0);
+    } else {
+      this.x += x[0];
+      this.y += x[1];
+      this.z += x[2];
+      this.w += x[3];
+    }
+    return this;
+  }
+  static add(v1, x, y, z, w) {
+    return v1.copy().add(x, y, z, w);
+  }
+  sub(x, y, z, w) {
+    if (typeof x === "number") {
+      this.x -= x;
+      this.y -= y ?? x;
+      this.z -= z ?? (y === void 0 ? x : 0);
+      this.w -= w ?? (z === void 0 ? x : 0);
+    } else {
+      this.x -= x[0];
+      this.y -= x[1];
+      this.z -= x[2];
+      this.w -= x[3];
+    }
+    return this;
+  }
+  static sub(v1, x, y, z, w) {
+    return v1.copy().sub(x, y, z, w);
+  }
+  mul(x, y, z, w) {
+    if (typeof x === "number") {
+      this.x *= x;
+      this.y *= y ?? x;
+      this.z *= z ?? (y === void 0 ? x : 1);
+      this.w *= w ?? (z === void 0 ? x : 1);
+    } else {
+      this.x *= x[0];
+      this.y *= x[1];
+      this.z *= x[2];
+      this.w *= x[3];
+    }
+    return this;
+  }
+  static mul(v1, x, y, z, w) {
+    return v1.copy().mul(x, y, z, w);
+  }
+  div(x, y, z, w) {
+    if (typeof x === "number") {
+      this.x /= x;
+      this.y /= y ?? x;
+      this.z /= z ?? (y === void 0 ? x : 1);
+      this.w /= w ?? (z === void 0 ? x : 1);
+    } else {
+      this.x /= x[0];
+      this.y /= x[1];
+      this.z /= x[2];
+      this.w /= x[3];
+    }
+    return this;
+  }
+  static div(v1, x, y, z, w) {
+    return v1.copy().div(x, y, z, w);
+  }
+  static fma(a, b, c) {
+    return vec4(
+      a[0] * b[0] + c[0],
+      a[1] * b[1] + c[1],
+      a[2] * b[2] + c[2],
+      a[3] * b[3] + c[3]
+    );
+  }
+  lt(x) {
+    return vec4(
+      this.x < x[0] ? 1 : 0,
+      this.y < x[1] ? 1 : 0,
+      this.z < x[2] ? 1 : 0,
+      this.w < x[3] ? 1 : 0
+    );
+  }
+  lte(x) {
+    return vec4(
+      this.x <= x[0] ? 1 : 0,
+      this.y <= x[1] ? 1 : 0,
+      this.z <= x[2] ? 1 : 0,
+      this.w <= x[3] ? 1 : 0
+    );
+  }
+  gt(x) {
+    return vec4(
+      this.x > x[0] ? 1 : 0,
+      this.y > x[1] ? 1 : 0,
+      this.z > x[2] ? 1 : 0,
+      this.w > x[3] ? 1 : 0
+    );
+  }
+  gte(x) {
+    return vec4(
+      this.x >= x[0] ? 1 : 0,
+      this.y >= x[1] ? 1 : 0,
+      this.z >= x[2] ? 1 : 0,
+      this.w >= x[3] ? 1 : 0
+    );
+  }
+  limit(max2) {
+    const maxSq = max2 * max2;
+    const magSq = this.magSq();
+    if (magSq > maxSq) {
+      this.setMag(max2);
+    }
+    return this;
+  }
+  normalize() {
+    const mag = this.mag();
+    if (mag !== 0) {
+      this.div(mag);
+    }
+    return this;
+  }
+  static normalize(v) {
+    return v.copy().normalize();
+  }
+  mag() {
+    return Math.sqrt(this.magSq());
+  }
+  setMag(n) {
+    return this.normalize().mul(n);
+  }
+  magSq() {
+    const { x, y, z, w } = this;
+    return x * x + y * y + z * z + w * w;
+  }
+  dist(v) {
+    return Math.sqrt(this.distSq(v));
+  }
+  distSq(v) {
+    return _Vec4.sub(v, this).magSq();
+  }
+  dot(v) {
+    const { x, y, z, w } = this;
+    return x * v[0] + y * v[1] + z * v[2] + w * v[3];
+  }
+  lerp(v, norm2) {
+    const { x, y, z, w } = this;
+    this.x = lerp(x, v[0], norm2);
+    this.y = lerp(y, v[1], norm2);
+    this.z = lerp(z, v[2], norm2);
+    this.w = lerp(w, v[3], norm2);
+    return this;
+  }
+  static lerp(v1, v2, norm2) {
+    return v1.copy().lerp(v2, norm2);
+  }
+  clamp(min2, max2) {
+    const { x, y, z, w } = this;
+    this.x = clamp(x, min2[0], max2[0]);
+    this.y = clamp(y, min2[1], max2[1]);
+    this.z = clamp(z, min2[2], max2[2]);
+    this.w = clamp(w, min2[3], max2[3]);
+    return this;
+  }
+  static clamp(v, min2, max2) {
+    return v.copy().clamp(min2, max2);
+  }
+  reflect(normal) {
+    return this.sub(_Vec4.mul(normal, 2 * this.dot(normal)));
+  }
+  static reflect(v, normal) {
+    return v.copy().reflect(normal);
+  }
+  refract(normal, eta) {
+    const nDot = this.dot(normal);
+    const k = 1 - eta * eta * (1 - nDot * nDot);
+    if (k < 0) {
+      this.x = this.y = this.z = this.w = 0;
+      return this;
+    }
+    return this.sub(_Vec4.mul(normal, eta * nDot + Math.sqrt(k)));
+  }
+};
+function vec4(x, y, z, w) {
+  return new Vec4(x, y, z, w);
+}
+
+export {
+  min,
+  max,
+  minmax,
+  sum,
+  product,
+  avg,
+  median,
+  mode,
+  variance,
+  stddev,
+  meanAbsDev,
+  isNumber,
+  isReal,
+  isInteger,
+  roundToMultiple,
+  roundToEven,
+  norm,
+  lerp,
+  map2 as map,
+  step,
+  smoothstep,
+  smootherstep,
+  clamp,
+  overlap,
+  closer,
+  round,
+  floor,
+  ceil,
+  trunc,
+  fract,
+  closeTo,
+  factorial,
+  log,
+  ln,
+  gcd,
+  fibonacci,
+  celsius,
+  fahrenheit,
+  lineOfBestFit,
+  permutations,
+  combinations,
+  dot,
+  Mat,
+  mat,
+  Mat2,
+  mat2,
+  Mat3,
+  mat3,
+  Mat4,
+  mat4,
+  DEG2RAD,
+  degrees,
+  radians,
+  Vec2,
+  vec2,
+  Vec3,
+  vec3,
+  Vec4,
+  vec4
+};