@jrc03c/make-key 0.0.34 → 0.0.36

package/dist/make-key.js

@@ -1,55 +1,25 @@
 (() => {
-  var __create = Object.create;
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __getProtoOf = Object.getPrototypeOf;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-  }) : x)(function(x) {
-    if (typeof require !== "undefined")
-      return require.apply(this, arguments);
-    throw new Error('Dynamic require of "' + x + '" is not supported');
-  });
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
-    // If the importer is in node compatibility mode or this is not an ESM
-    // file that has been converted to a CommonJS file using a Babel-
-    // compatible transform (i.e. "__esModule" has not been set), then set
-    // "default" to the CommonJS "module.exports" for node compatibility.
-    isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
-    mod2
-  ));
-
-  // node_modules/@jrc03c/js-math-tools/dist/js-math-tools.import.mjs
-  var __defProp2 = Object.defineProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
+  // node_modules/@jrc03c/js-math-tools/src/is-number.mjs
   function isNumber(x) {
     return typeof x === "number" && !isNaN(x) || typeof x === "bigint";
   }
-  var isBrowser = new Function(`
-  try {
-    return this === window
-  } catch(e) {}
 
-  try {
-    return typeof importScripts !== "undefined"
-  } catch(e) {}
+  // node_modules/@jrc03c/js-math-tools/src/is-browser.mjs
+  var isBrowser = new Function(
+    `
+    try {
+      return this === window
+    } catch(e) {}
+
+    try {
+      return !!importScripts
+    } catch(e){}
+
+    return false
+  `
+  );
 
-  return false
-`);
+  // node_modules/@jrc03c/js-math-tools/src/math-error.mjs
   var MathError = class extends Error {
     constructor(message) {
       if (isBrowser()) {
@@ -59,10 +29,13 @@
       }
     }
   };
+
+  // node_modules/@jrc03c/js-math-tools/src/assert.mjs
   function assert(isTrue, message) {
-    if (!isTrue)
-      throw new MathError(message);
+    if (!isTrue) throw new MathError(message);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/helpers/array-types.mjs
   var arrayTypes = [
     Array,
     ArrayBuffer,
@@ -78,9 +51,13 @@
     Uint8Array,
     Uint8ClampedArray
   ];
+
+  // node_modules/@jrc03c/js-math-tools/src/is-undefined.mjs
   function isUndefined(x) {
     return x === null || typeof x === "undefined";
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-array.mjs
   var typeStrings = arrayTypes.map((s2) => s2.name);
   function isArray(obj) {
     try {
@@ -95,6 +72,8 @@
       return false;
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-dataframe.mjs
   function isDataFrame(x) {
     try {
       return !!x._symbol && x._symbol === Symbol.for("@jrc03c/js-math-tools/dataframe");
@@ -102,12 +81,18 @@
       return false;
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-function.mjs
   function isFunction(fn) {
     return typeof fn === "function";
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-object.mjs
   function isObject(x) {
     return typeof x === "object" && !isUndefined(x) && !isArray(x);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-series.mjs
   function isSeries(x) {
     try {
       return !!x._symbol && x._symbol === Symbol.for("@jrc03c/js-math-tools/series");
@@ -115,6 +100,8 @@
       return false;
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/index-of.mjs
   function indexOf(x, fn) {
     if (isDataFrame(x)) {
       const index = indexOf(x.values, fn);
@@ -133,12 +120,15 @@
       }
       return index;
     }
-    assert(isObject(x) || isArray(x), "You must pass (1) an object, array, Series, or DataFrame and (2) a function or value into the `indexOf` function!");
+    assert(
+      isObject(x) || isArray(x),
+      "You must pass (1) an object, array, Series, or DataFrame and (2) a function or value into the `indexOf` function!"
+    );
     if (!isFunction(fn)) {
       const value = fn;
       fn = (v) => v === value;
     }
-    function helper5(x2, fn2, checked) {
+    function helper4(x2, fn2, checked) {
       checked = checked || [];
       if (checked.indexOf(x2) > -1) {
         return null;
@@ -152,7 +142,7 @@
           if (fn2(value)) {
             return [key];
           }
-          const results = helper5(value, fn2, checked);
+          const results = helper4(value, fn2, checked);
           if (results && results.length > 0) {
             return [key].concat(results);
           }
@@ -164,7 +154,7 @@
           if (fn2(value)) {
             return [i];
           }
-          const results = helper5(value, fn2, checked);
+          const results = helper4(value, fn2, checked);
           if (results && results.length > 0) {
             return [i].concat(results);
           }
@@ -183,15 +173,17 @@
         return false;
       }
     }
-    const paths = helper5(x, safeFn);
+    const paths = helper4(x, safeFn);
     if (paths && paths.length > 0) {
       return paths;
     } else {
       return null;
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/copy.mjs
   function copy(x) {
-    function helper5(x2) {
+    function helper4(x2) {
       if (typeof x2 === "object") {
         if (x2 === null) {
           return null;
@@ -203,32 +195,32 @@
           return x2.map((v) => copy(v));
         }
         if (isSeries(x2)) {
-          const out3 = x2.copy();
-          out3.values = copy(out3.values);
-          return out3;
+          const out2 = x2.copy();
+          out2.values = copy(out2.values);
+          return out2;
         }
         if (isDataFrame(x2)) {
-          const out3 = x2.copy();
-          out3.values = copy(x2.values);
-          return out3;
+          const out2 = x2.copy();
+          out2.values = copy(x2.values);
+          return out2;
         }
         if (x2 instanceof Date) {
           return new Date(x2.getTime());
         }
         x2 = decycle(x2);
-        const out2 = {};
+        const out = {};
         Object.keys(x2).concat(Object.getOwnPropertySymbols(x2)).forEach((key) => {
-          out2[key] = copy(x2[key]);
+          out[key] = copy(x2[key]);
         });
-        return out2;
+        return out;
       } else {
         return x2;
       }
     }
-    return helper5(decycle(x));
+    return helper4(decycle(x));
   }
   function decycle(x) {
-    function helper5(x2, checked, currentPath) {
+    function helper4(x2, checked, currentPath) {
       checked = checked || [];
       currentPath = currentPath || "";
       if (checked.indexOf(x2) > -1) {
@@ -247,17 +239,16 @@
         }
       }
       if (typeof x2 === "object") {
-        if (x2 === null)
-          return null;
+        if (x2 === null) return null;
         checked.push(x2);
         if (isArray(x2)) {
           if (typeof x2.constructor !== "undefined" && x2.constructor.name !== "Array") {
             return x2.slice();
           }
-          return x2.map((v, i) => helper5(v, checked, currentPath + "/" + i));
+          return x2.map((v, i) => helper4(v, checked, currentPath + "/" + i));
         } else {
           Object.keys(x2).concat(Object.getOwnPropertySymbols(x2)).forEach((key) => {
-            x2[key] = helper5(x2[key], checked, currentPath + "/" + key.toString());
+            x2[key] = helper4(x2[key], checked, currentPath + "/" + key.toString());
           });
           return x2;
         }
@@ -266,39 +257,40 @@
       }
     }
     const orig = x;
-    let out2 = helper5(orig);
+    let out = helper4(orig);
     if (isDataFrame(x)) {
       const temp = x.copy();
-      temp._values = out2.values;
-      temp._columns = out2.columns;
-      temp._index = out2.index;
-      out2 = temp;
+      temp._values = out.values;
+      temp._columns = out.columns;
+      temp._index = out.index;
+      out = temp;
     }
     if (isSeries(x)) {
       const temp = x.copy();
-      temp.name = out2.name;
-      temp._values = out2.values;
-      temp._index = out2.index;
-      out2 = temp;
+      temp.name = out.name;
+      temp._values = out.values;
+      temp._index = out.index;
+      out = temp;
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-date.mjs
   function isDate(x) {
     return x instanceof Date && x.toString() !== "Invalid Date";
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-equal.mjs
   var numberTypes = ["number", "int", "float", "bigint"];
   function isEqual(a, b) {
-    function helper5(a2, b2) {
+    function helper4(a2, b2) {
       const aType = typeof a2;
       const bType = typeof b2;
       if (aType !== bType && !numberTypes.includes(aType) && !numberTypes.includes(bType))
         return false;
-      if (aType === "undefined" && bType === "undefined")
-        return true;
-      if (aType === "boolean")
-        return a2 === b2;
-      if (aType === "symbol")
-        return a2 === b2;
+      if (aType === "undefined" && bType === "undefined") return true;
+      if (aType === "boolean") return a2 === b2;
+      if (aType === "symbol") return a2 === b2;
       if (aType === "number" || aType === "bigint") {
         try {
           const aString = a2.toString();
@@ -308,10 +300,8 @@
           return false;
         }
       }
-      if (aType === "string")
-        return a2 === b2;
-      if (aType === "function")
-        return a2 === b2;
+      if (aType === "string") return a2 === b2;
+      if (aType === "function") return a2 === b2;
       if (aType === "object") {
         if (a2 === null || b2 === null) {
           return a2 === null && b2 === null;
@@ -333,29 +323,28 @@
           }
           const aKeys = Object.keys(a2).concat(Object.getOwnPropertySymbols(a2));
           const bKeys = Object.keys(b2).concat(Object.getOwnPropertySymbols(b2));
-          if (aKeys.length !== bKeys.length)
-            return false;
+          if (aKeys.length !== bKeys.length) return false;
           for (let i = 0; i < aKeys.length; i++) {
             const key = aKeys[i];
-            if (!helper5(a2[key], b2[key]))
-              return false;
+            if (!helper4(a2[key], b2[key])) return false;
           }
           return true;
         }
       }
     }
     try {
-      return helper5(a, b);
+      return helper4(a, b);
     } catch (e) {
-      return helper5(decycle(a), decycle(b));
+      return helper4(decycle(a), decycle(b));
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/helpers/counter.mjs
   function makeKey(n) {
     const alpha = "abcdefg1234567890";
-    let out2 = "";
-    while (out2.length < n)
-      out2 += alpha[Math.floor(Math.random() * alpha.length)];
-    return out2;
+    let out = "";
+    while (out.length < n) out += alpha[Math.floor(Math.random() * alpha.length)];
+    return out;
   }
   var NULL_KEY = makeKey(16);
   var UNDEFINED_KEY = makeKey(16);
@@ -415,35 +404,42 @@
       return this.values.map((v) => ({ value: v, count: this.get(v) }));
     }
     toObject() {
-      const out2 = {};
+      const out = {};
       this.values.forEach((value) => {
-        out2[value] = this.get(value);
+        out[value] = this.get(value);
       });
-      return out2;
+      return out;
     }
   };
+
+  // node_modules/@jrc03c/js-math-tools/src/flatten.mjs
   function flatten(arr) {
     if (isDataFrame(arr) || isSeries(arr)) {
       return flatten(arr.values);
     }
-    assert(isArray(arr), "The `flatten` function only works on arrays, Series, and DataFrames!");
-    function helper5(arr2) {
-      let out2 = [];
+    assert(
+      isArray(arr),
+      "The `flatten` function only works on arrays, Series, and DataFrames!"
+    );
+    function helper4(arr2) {
+      let out = [];
       arr2.forEach((child) => {
         if (isArray(child)) {
-          out2 = out2.concat(helper5(child));
+          out = out.concat(helper4(child));
         } else {
-          out2.push(child);
+          out.push(child);
         }
       });
-      return out2;
+      return out;
     }
-    return helper5(arr);
+    return helper4(arr);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/stats.mjs
   function stats(x, options) {
     options = options || {};
     const counts = new Counter();
-    const out2 = {};
+    const out = {};
     const xflat = flatten(x);
     const xnums = [];
     let max2 = -Infinity;
@@ -473,21 +469,23 @@
       counts.increment(v);
     }
     const mean2 = sum2 / xnums.length;
-    out2.counts = counts;
-    out2.max = max2;
-    out2.mean = mean2;
-    out2.min = min2;
-    out2.n = xflat.length;
-    out2.sum = sum2;
-    if (isNaN(out2.mean)) {
-      out2.max = NaN;
-      out2.min = NaN;
+    out.counts = counts;
+    out.max = max2;
+    out.mean = mean2;
+    out.min = min2;
+    out.n = xflat.length;
+    out.sum = sum2;
+    if (isNaN(out.mean)) {
+      out.max = NaN;
+      out.min = NaN;
     }
     if (options.shouldDropNaNs) {
-      out2.nWithoutNaNs = xnums.length;
+      out.nWithoutNaNs = xnums.length;
     }
     if (options.mode) {
-      const sortedCountPairs = Array.from(counts.values.map((v) => [v, counts.get(v)])).toSorted((a, b) => b[1] - a[1]);
+      const sortedCountPairs = Array.from(
+        counts.values.map((v) => [v, counts.get(v)])
+      ).toSorted((a, b) => b[1] - a[1]);
       const highestCount = sortedCountPairs[0][1];
       const mode2 = [];
       for (const pair of sortedCountPairs) {
@@ -497,26 +495,26 @@
           break;
         }
       }
-      out2.mode = mode2.toSorted();
+      out.mode = mode2.toSorted();
     }
     if (options.median) {
       if (isNaN(mean2)) {
-        out2.median = NaN;
+        out.median = NaN;
       } else {
         const xnumsSorted = xnums.toSorted((a, b) => Number(a) - Number(b));
         const middle = Math.floor(xnumsSorted.length / 2);
         if (xnumsSorted.length % 2 === 0) {
           const left = xnumsSorted[middle - 1];
           const right = xnumsSorted[middle];
-          out2.median = (Number(left) + Number(right)) / 2;
+          out.median = (Number(left) + Number(right)) / 2;
           if (resultsShouldIncludeBigInts && typeof left === "bigint" && typeof right === "bigint") {
             try {
-              out2.median = BigInt(out2.median);
+              out.median = BigInt(out.median);
             } catch (e) {
             }
           }
         } else {
-          out2.median = xnumsSorted[middle];
+          out.median = xnumsSorted[middle];
         }
       }
     }
@@ -527,20 +525,20 @@
       }
       variance2 /= xnums.length;
       const stdev2 = Math.sqrt(variance2);
-      out2.stdev = stdev2;
-      out2.variance = variance2;
+      out.stdev = stdev2;
+      out.variance = variance2;
     }
     if (resultsShouldIncludeBigInts) {
       try {
-        out2.sum = BigInt(out2.sum);
+        out.sum = BigInt(out.sum);
       } catch (e) {
       }
       try {
-        out2.mean = BigInt(out2.mean);
+        out.mean = BigInt(out.mean);
       } catch (e) {
       }
       if (options.mode) {
-        out2.mode = out2.mode.map((v) => {
+        out.mode = out.mode.map((v) => {
           try {
             return BigInt(v);
           } catch (e) {
@@ -549,8 +547,10 @@
         });
       }
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/count.mjs
   function count(arr, matcher) {
     const { counts } = stats(arr);
     if (!isUndefined(matcher)) {
@@ -570,6 +570,8 @@
     }
     return counts;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-jagged.mjs
   function helper(x) {
     if (isDataFrame(x) || isSeries(x)) {
       return helper(x.values);
@@ -602,11 +604,16 @@
   function isJagged(x) {
     return helper(decycle(x));
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-nested.mjs
   function isNested(x) {
     if (isDataFrame(x) || isSeries(x)) {
       return isNested(x.values);
     }
-    assert(isArray(x), "The `isNested` function only works on arrays, Series, and DataFrames!");
+    assert(
+      isArray(x),
+      "The `isNested` function only works on arrays, Series, and DataFrames!"
+    );
     for (let i = 0; i < x.length; i++) {
       if (isArray(x[i])) {
         return true;
@@ -614,50 +621,67 @@
     }
     return false;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/ndarray.mjs
   var error = "You must pass a natural number or a one-dimensional array of natural numbers into the `ndarray` function!";
   function ndarray(shape2) {
     assert(!isUndefined(shape2), error);
-    if (!isArray(shape2))
-      shape2 = [shape2];
+    if (!isArray(shape2)) shape2 = [shape2];
     assert(!isNested(shape2), error);
     assert(shape2.length > 0, error);
     let s2 = shape2[0];
-    if (typeof s2 === "bigint")
-      s2 = Number(s2);
+    if (typeof s2 === "bigint") s2 = Number(s2);
     assert(isNumber(s2), error);
     assert(s2 >= 0, error);
     assert(Math.floor(s2) === s2, error);
-    assert(s2 !== Infinity, "We can't create an array containing an infinite number of values!");
+    assert(
+      s2 !== Infinity,
+      "We can't create an array containing an infinite number of values!"
+    );
     if (shape2.length === 1) {
-      const out2 = [];
-      for (let i = 0; i < s2; i++)
-        out2.push(void 0);
-      return out2;
+      const out = [];
+      for (let i = 0; i < s2; i++) out.push(void 0);
+      return out;
     } else {
-      const out2 = [];
+      const out = [];
       for (let i = 0; i < s2; i++) {
-        out2.push(ndarray(shape2.slice(1)));
+        out.push(ndarray(shape2.slice(1)));
       }
-      return out2;
+      return out;
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/reverse.mjs
   function reverse(arr) {
     if (isDataFrame(arr) || isSeries(arr)) {
-      const out3 = arr.copy();
-      out3.values = reverse(out3.values);
-      out3.index = reverse(out3.index);
-      return out3;
-    }
-    assert(isArray(arr), "The `reverse` function only works on arrays, Series, and DataFrames!");
-    const out2 = [];
-    for (let i = arr.length - 1; i >= 0; i--)
-      out2.push(arr[i]);
-    return out2;
+      const out2 = arr.copy();
+      out2.values = reverse(out2.values);
+      out2.index = reverse(out2.index);
+      return out2;
+    }
+    assert(
+      isArray(arr),
+      "The `reverse` function only works on arrays, Series, and DataFrames!"
+    );
+    const out = [];
+    for (let i = arr.length - 1; i >= 0; i--) out.push(arr[i]);
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/range.mjs
   function range(a, b, step = 1) {
-    assert(!isUndefined(a) && !isUndefined(b) && !isUndefined(step), "You must pass two numbers and optionally a step value to the `range` function!");
-    assert(isNumber(a) && isNumber(b) && isNumber(step), "You must pass two numbers and optionally a step value to the `range` function!");
-    assert(step > 0, "The step value must be greater than 0! (NOTE: The step value is a magnitude; it does not indicate direction.)");
+    assert(
+      !isUndefined(a) && !isUndefined(b) && !isUndefined(step),
+      "You must pass two numbers and optionally a step value to the `range` function!"
+    );
+    assert(
+      isNumber(a) && isNumber(b) && isNumber(step),
+      "You must pass two numbers and optionally a step value to the `range` function!"
+    );
+    assert(
+      step > 0,
+      "The step value must be greater than 0! (NOTE: The step value is a magnitude; it does not indicate direction.)"
+    );
     let shouldReverse = false;
     const shouldIncludeBigInts = typeof a === "bigint" || typeof b === "bigint" || typeof step === "bigint";
     a = Number(a);
@@ -669,28 +693,28 @@
       a = b + step;
       b = buffer + step;
     }
-    let out2 = [];
+    let out = [];
     for (let i = a; i < b; i += step) {
       if (shouldIncludeBigInts) {
         try {
-          out2.push(BigInt(i));
+          out.push(BigInt(i));
         } catch (e) {
-          out2.push(i);
+          out.push(i);
         }
       } else {
-        out2.push(i);
+        out.push(i);
       }
     }
-    if (shouldReverse)
-      out2 = reverse(out2);
-    return out2;
+    if (shouldReverse) out = reverse(out);
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/set.mjs
   function makeKey2(n) {
     const alpha = "abcdefg1234567890";
-    let out2 = "";
-    while (out2.length < n)
-      out2 += alpha[Math.floor(Math.random() * alpha.length)];
-    return out2;
+    let out = "";
+    while (out.length < n) out += alpha[Math.floor(Math.random() * alpha.length)];
+    return out;
   }
   var NULL_KEY2 = makeKey2(256);
   var UNDEFINED_KEY2 = makeKey2(256);
@@ -701,17 +725,21 @@
     if (isDataFrame(arr) || isSeries(arr)) {
       return set(arr.values);
     }
-    assert(isArray(arr), "The `set` function only works on arrays, Series, and DataFrames!");
-    const out2 = [];
+    assert(
+      isArray(arr),
+      "The `set` function only works on arrays, Series, and DataFrames!"
+    );
+    const out = [];
     const temp = {};
     flatten(arr).forEach((item) => {
       const key = typeof item === "object" && item === null ? NULL_KEY2 : isUndefined(item) ? UNDEFINED_KEY2 : isFunction(item) ? item.toString() : typeof item === "symbol" ? item.toString() + " - " + SYMBOL_KEY2 : item === Infinity ? INFINITY_KEY2 : item === -Infinity ? MINUS_INFINITY_KEY2 : typeof item === "bigint" ? item.toString() : isDataFrame(item) ? item.toJSONString() : isSeries(item) ? JSON.stringify(item.toObject()) : JSON.stringify(item);
-      if (!temp[key])
-        out2.push(item);
+      if (!temp[key]) out.push(item);
       temp[key] = true;
     });
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/shape.mjs
   function helper2(x) {
     if (isArray(x)) {
       const childShapes = helper2(x[0]);
@@ -724,105 +752,120 @@
     if (isDataFrame(x) || isSeries(x)) {
       return shape(x.values);
     }
-    assert(isArray(x), "The `shape` function only works on arrays, Series, and DataFrames!");
+    assert(
+      isArray(x),
+      "The `shape` function only works on arrays, Series, and DataFrames!"
+    );
     return helper2(x);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-append.mjs
   function dfAppend(df, x, axis) {
     if (isUndefined(axis)) {
       axis = 0;
     }
-    assert(axis === 0 || axis === 1 || axis === "vertical" || axis === "horizontal", 'The only valid axis values for use when appending data to a DataFrame are 0, 1, "vertical", and "horizontal". Note that 0 == "horizontal" and 1 == "vertical".');
+    assert(
+      axis === 0 || axis === 1 || axis === "vertical" || axis === "horizontal",
+      'The only valid axis values for use when appending data to a DataFrame are 0, 1, "vertical", and "horizontal". Note that 0 == "horizontal" and 1 == "vertical".'
+    );
     if (isArray(x)) {
-      assert(!isJagged(x), "The array of data you're trying to append to this DataFrame is jagged!");
+      assert(
+        !isJagged(x),
+        "The array of data you're trying to append to this DataFrame is jagged!"
+      );
       const xShape = shape(x);
       if (xShape.length === 1) {
         if (axis === 0) {
-          const out2 = df.copy();
-          out2._values.push(x);
+          const out = df.copy();
+          out._values.push(x);
           const maxRowLength = Math.max(df.shape[1], xShape[0]);
-          out2._values.forEach((row) => {
+          out._values.forEach((row) => {
             while (row.length < maxRowLength) {
               row.push(void 0);
             }
           });
-          while (out2._index.length < out2._values.length) {
-            out2._index.push("row" + out2._index.length);
+          while (out._index.length < out._values.length) {
+            out._index.push("row" + out._index.length);
           }
-          while (out2._columns.length < maxRowLength) {
-            out2._columns.push("col" + out2._columns.length);
+          while (out._columns.length < maxRowLength) {
+            out._columns.push("col" + out._columns.length);
           }
-          return out2;
+          return out;
         } else {
           const maxColLength = Math.max(df.shape[0], xShape[0]);
-          const out2 = df.copy();
+          const out = df.copy();
           range(0, maxColLength).forEach((i) => {
-            if (i >= out2._values.length) {
-              out2._values.push(ndarray(df.shape[1]));
+            if (i >= out._values.length) {
+              out._values.push(ndarray(df.shape[1]));
             }
-            out2._values[i].push(x[i]);
+            out._values[i].push(x[i]);
           });
-          while (out2._index.length < out2._values.length) {
-            out2._index.push("row" + out2._index.length);
+          while (out._index.length < out._values.length) {
+            out._index.push("row" + out._index.length);
           }
-          while (out2._columns.length < out2._values[0].length) {
-            out2._columns.push("col" + out2._columns.length);
+          while (out._columns.length < out._values[0].length) {
+            out._columns.push("col" + out._columns.length);
           }
-          return out2;
+          return out;
         }
       } else if (xShape.length === 2) {
         if (axis === 0) {
-          const maxRowLength = Math.max(...x.map((row) => row.length).concat([df.shape[1]]));
-          const out2 = df.copy();
-          out2._values = out2._values.concat(x).map((row) => {
+          const maxRowLength = Math.max(
+            ...x.map((row) => row.length).concat([df.shape[1]])
+          );
+          const out = df.copy();
+          out._values = out._values.concat(x).map((row) => {
             while (row.length < maxRowLength) {
               row.push(void 0);
             }
             return row;
           });
-          while (out2._index.length < out2._values.length) {
-            out2._index.push("row" + out2._index.length);
+          while (out._index.length < out._values.length) {
+            out._index.push("row" + out._index.length);
           }
-          while (out2._columns.length < maxRowLength) {
-            out2._columns.push("col" + out2._columns.length);
+          while (out._columns.length < maxRowLength) {
+            out._columns.push("col" + out._columns.length);
           }
-          return out2;
+          return out;
         } else {
           const maxRowLength = Math.max(...x.map((row) => row.length)) + df.shape[1];
           const maxColLength = Math.max(df.shape[0], xShape[0]);
-          const out2 = df.copy();
+          const out = df.copy();
           range(0, maxColLength).forEach((i) => {
-            if (i >= out2._values.length) {
-              out2._values.push(ndarray(df.shape[1]));
+            if (i >= out._values.length) {
+              out._values.push(ndarray(df.shape[1]));
             }
-            out2._values[i] = out2._values[i].concat(x[i]);
-            while (out2._values[i].length < maxRowLength) {
-              out2._values[i].push(void 0);
+            out._values[i] = out._values[i].concat(x[i]);
+            while (out._values[i].length < maxRowLength) {
+              out._values[i].push(void 0);
             }
           });
-          while (out2._index.length < out2._values.length) {
-            out2._index.push("row" + out2._index.length);
+          while (out._index.length < out._values.length) {
+            out._index.push("row" + out._index.length);
           }
-          while (out2._columns.length < maxRowLength) {
-            out2._columns.push("col" + out2._columns.length);
+          while (out._columns.length < maxRowLength) {
+            out._columns.push("col" + out._columns.length);
           }
-          return out2;
+          return out;
         }
       } else {
-        throw new MathError("Only 1- and 2-dimensional arrays can be appended to a DataFrame!");
+        throw new MathError(
+          "Only 1- and 2-dimensional arrays can be appended to a DataFrame!"
+        );
       }
     } else if (isSeries(x)) {
-      const out2 = dfAppend(df, x.values, axis);
+      const out = dfAppend(df, x.values, axis);
       if (axis === 0) {
-        out2.index[out2.index.length - 1] = out2.index.indexOf(x.name) > -1 ? x.name + " (2)" : x.name;
+        out.index[out.index.length - 1] = out.index.indexOf(x.name) > -1 ? x.name + " (2)" : x.name;
       } else {
-        out2.columns[out2.columns.length - 1] = out2.columns.indexOf(x.name) > -1 ? x.name + " (2)" : x.name;
+        out.columns[out.columns.length - 1] = out.columns.indexOf(x.name) > -1 ? x.name + " (2)" : x.name;
       }
-      return out2;
+      return out;
     } else if (isDataFrame(x)) {
       if (axis === 0) {
-        const out2 = df.copy();
-        const maxRowLength = set(out2._columns.concat(x._columns)).length;
-        out2._values.forEach((row) => {
+        const out = df.copy();
+        const maxRowLength = set(out._columns.concat(x._columns)).length;
+        out._values.forEach((row) => {
           while (row.length < maxRowLength) {
             row.push(void 0);
           }
@@ -830,7 +873,7 @@
         x.apply((row) => {
           const rowCopy = row.copy();
           const temp = [];
-          out2._columns.forEach((col) => {
+          out._columns.forEach((col) => {
             const index = rowCopy._index.indexOf(col);
             if (index > -1) {
               temp.push(rowCopy._values[index]);
@@ -840,42 +883,58 @@
               temp.push(void 0);
             }
           });
-          out2._values.push(temp.concat(rowCopy._values));
+          out._values.push(temp.concat(rowCopy._values));
         }, 1);
-        out2._columns = out2._columns.concat(x._columns.filter((c) => out2._columns.indexOf(c) < 0));
-        while (out2._index.length < out2._values.length) {
-          const newRowName = "row" + out2._index.length;
-          out2._index.push(newRowName + (df._index.indexOf(newRowName) > -1 ? " (2)" : ""));
-        }
-        return out2;
+        out._columns = out._columns.concat(
+          x._columns.filter((c) => out._columns.indexOf(c) < 0)
+        );
+        while (out._index.length < out._values.length) {
+          const newRowName = "row" + out._index.length;
+          out._index.push(
+            newRowName + (df._index.indexOf(newRowName) > -1 ? " (2)" : "")
+          );
+        }
+        return out;
       } else {
-        const out2 = df.copy();
-        out2._index.forEach((rowName, i) => {
+        const out = df.copy();
+        out._index.forEach((rowName, i) => {
           const xIndex = x._index.indexOf(rowName);
           if (xIndex > -1) {
-            out2._values[i] = out2._values[i].concat(x._values[xIndex]);
+            out._values[i] = out._values[i].concat(x._values[xIndex]);
           } else {
-            out2._values[i] = out2._values[i].concat(ndarray(x.shape[1]));
+            out._values[i] = out._values[i].concat(ndarray(x.shape[1]));
           }
         });
         x._index.forEach((rowName, i) => {
-          const outIndex = out2._index.indexOf(rowName);
+          const outIndex = out._index.indexOf(rowName);
           if (outIndex < 0) {
-            out2._index.push(rowName);
-            out2._values.push(ndarray(out2._columns.length).concat(x._values[i]));
+            out._index.push(rowName);
+            out._values.push(ndarray(out._columns.length).concat(x._values[i]));
           }
         });
-        out2._columns = out2._columns.concat(x._columns.map((c) => c + (out2._columns.indexOf(c) > -1 ? " (2)" : "")));
-        return out2;
+        out._columns = out._columns.concat(
+          x._columns.map((c) => c + (out._columns.indexOf(c) > -1 ? " (2)" : ""))
+        );
+        return out;
       }
     } else {
-      throw new MathError("Only 1- or 2-dimensional arrays, Series, and DataFrames can be appended to a DataFrame!");
+      throw new MathError(
+        "Only 1- or 2-dimensional arrays, Series, and DataFrames can be appended to a DataFrame!"
+      );
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-apply.mjs
   function dfApply(DataFrame2, Series2, df, fn, axis) {
     axis = axis || 0;
-    assert(isFunction(fn), "The first parameter to the `apply` method must be a function.");
-    assert(axis === 0 || axis === 1, "The second parameter to the `apply` method (the `axis`) must be 0 or 1.");
+    assert(
+      isFunction(fn),
+      "The first parameter to the `apply` method must be a function."
+    );
+    assert(
+      axis === 0 || axis === 1,
+      "The second parameter to the `apply` method (the `axis`) must be 0 or 1."
+    );
     if (axis === 0) {
       const temp = {};
       let shouldReturnADataFrame;
@@ -894,13 +953,13 @@
         }
       });
       if (shouldReturnADataFrame) {
-        const out2 = new DataFrame2(temp);
-        out2.index = df.index;
-        return out2;
+        const out = new DataFrame2(temp);
+        out.index = df.index;
+        return out;
       } else {
-        const out2 = new Series2(df.columns.map((colName) => temp[colName]));
-        out2.index = df.columns;
-        return out2;
+        const out = new Series2(df.columns.map((colName) => temp[colName]));
+        out.index = df.columns;
+        return out;
       }
     } else if (axis === 1) {
       let shouldReturnADataFrame;
@@ -919,36 +978,48 @@
         }
       });
       if (shouldReturnADataFrame) {
-        const out2 = new DataFrame2(temp);
-        out2.index = df.index;
-        out2.columns = df.columns;
-        return out2;
+        const out = new DataFrame2(temp);
+        out.index = df.index;
+        out.columns = df.columns;
+        return out;
       } else {
-        const out2 = new Series2(temp);
-        out2.index = df.index;
-        return out2;
+        const out = new Series2(temp);
+        out.index = df.index;
+        return out;
       }
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-string.mjs
   function isString(s2) {
     return typeof s2 === "string";
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-assign.mjs
   function dfAssign(DataFrame2, Series2, df, p1, p2) {
     const isDataFrame2 = (x) => x instanceof DataFrame2;
     const isSeries2 = (x) => x instanceof Series2;
     if (!isUndefined(p2)) {
-      assert(isString(p1), "If passing two arguments into the `assign` method, then the first argument must be a string name!");
-      assert(isArray(p2) && !isJagged(p2) && shape(p2).length === 1, "If passing two arguments into the `assign` method, then the second argument must be a 1-dimensional array!");
-      const out2 = df.append(p2, 1);
-      out2.columns[out2.columns.length - 1] = p1;
-      return out2;
+      assert(
+        isString(p1),
+        "If passing two arguments into the `assign` method, then the first argument must be a string name!"
+      );
+      assert(
+        isArray(p2) && !isJagged(p2) && shape(p2).length === 1,
+        "If passing two arguments into the `assign` method, then the second argument must be a 1-dimensional array!"
+      );
+      const out = df.append(p2, 1);
+      out.columns[out.columns.length - 1] = p1;
+      return out;
     } else {
       if (isDataFrame2(p1)) {
         return df.append(p1, 1);
       } else if (isSeries2(p1)) {
         return df.append(p1, 1);
       } else if (isObject(p1)) {
-        const maxColumnLength = Math.max(...Object.keys(p1).concat(Object.getOwnPropertySymbols(p1)).map((key) => p1[key].length));
+        const maxColumnLength = Math.max(
+          ...Object.keys(p1).concat(Object.getOwnPropertySymbols(p1)).map((key) => p1[key].length)
+        );
         Object.keys(p1).concat(Object.getOwnPropertySymbols(p1)).forEach((key) => {
           while (p1[key].length < maxColumnLength) {
             p1[key].push(void 0);
@@ -956,117 +1027,134 @@
         });
         return df.append(new DataFrame2(p1), 1);
       } else {
-        throw new MathError("You must pass a DataFrame, Series, or object into the `assign` method!");
+        throw new MathError(
+          "You must pass a DataFrame, Series, or object into the `assign` method!"
+        );
       }
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-copy.mjs
   function dfCopy(DataFrame2, df) {
-    if (df.isEmpty)
-      return new DataFrame2();
-    const out2 = new DataFrame2(copy(df.values));
-    out2.columns = df.columns.slice();
-    out2.index = df.index.slice();
-    return out2;
+    if (df.isEmpty) return new DataFrame2();
+    const out = new DataFrame2(copy(df.values));
+    out.columns = df.columns.slice();
+    out.index = df.index.slice();
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-drop.mjs
   function dfDrop(DataFrame2, Series2, df, rows, cols) {
-    if (isUndefined(rows))
-      rows = [];
-    if (isUndefined(cols))
-      cols = [];
-    if (isString(rows) || isNumber(rows))
-      rows = [rows];
-    if (isString(cols) || isNumber(cols))
-      cols = [cols];
-    assert(isArray(rows), "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings.");
-    assert(isArray(cols), "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings.");
-    assert(shape(rows).length === 1, "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings.");
-    assert(shape(cols).length === 1, "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings.");
+    if (isUndefined(rows)) rows = [];
+    if (isUndefined(cols)) cols = [];
+    if (isString(rows) || isNumber(rows)) rows = [rows];
+    if (isString(cols) || isNumber(cols)) cols = [cols];
+    assert(
+      isArray(rows),
+      "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings."
+    );
+    assert(
+      isArray(cols),
+      "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings."
+    );
+    assert(
+      shape(rows).length === 1,
+      "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings."
+    );
+    assert(
+      shape(cols).length === 1,
+      "The `drop` method only works on 1-dimensional arrays of numerical indices and/or strings."
+    );
     let outIndex, outColumns;
     df.index.forEach((row, i) => {
       if (rows.indexOf(row) < 0 && rows.indexOf(i) < 0) {
-        if (!outIndex)
-          outIndex = [];
+        if (!outIndex) outIndex = [];
         outIndex.push(row);
       }
     });
     df.columns.forEach((col, i) => {
       if (cols.indexOf(col) < 0 && cols.indexOf(i) < 0) {
-        if (!outColumns)
-          outColumns = [];
+        if (!outColumns) outColumns = [];
         outColumns.push(col);
       }
     });
-    let out2 = df.get(outIndex, outColumns);
-    if (out2 instanceof Series2) {
+    let out = df.get(outIndex, outColumns);
+    if (out instanceof Series2) {
       let temp = new DataFrame2();
-      temp = temp.assign(out2);
-      if (df.index.indexOf(out2.name) > -1)
-        temp = temp.transpose();
-      out2 = temp;
+      temp = temp.assign(out);
+      if (df.index.indexOf(out.name) > -1) temp = temp.transpose();
+      out = temp;
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/helpers/is-integer.mjs
   function isInteger(x) {
     return isNumber(x) && (x >= 0 ? Math.floor(x) === x : Math.ceil(x) === x);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/helpers/is-whole-number.mjs
   function isWholeNumber(x) {
     return isInteger(x) && x >= 0;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-drop-missing.mjs
   function dfDropMissing(DataFrame2, Series2, df, axis, condition, threshold) {
     axis = axis || 0;
-    assert(axis === 0 || axis === 1, "The first parameter of the `dropMissing` method (the `axis`) must be 0 or 1.");
+    assert(
+      axis === 0 || axis === 1,
+      "The first parameter of the `dropMissing` method (the `axis`) must be 0 or 1."
+    );
     threshold = threshold || 0;
-    assert(isWholeNumber(threshold), "The third parameter of the `dropMissing` method (the `threshold`) should be a whole number (meaning that data should be dropped if it contains more than `threshold` null values).");
+    assert(
+      isWholeNumber(threshold),
+      "The third parameter of the `dropMissing` method (the `threshold`) should be a whole number (meaning that data should be dropped if it contains more than `threshold` null values)."
+    );
     condition = threshold > 0 ? "none" : condition || "any";
-    assert(condition === "any" || condition === "all" || condition === "none", "The second parameter of the `dropMissing` method (the `condition` parameter, which indicates the condition under which data should be dropped) should be 'any' or 'all' (meaning that if 'any' of the data contains null values, then it should be dropped; or that if 'all' of the data contains null values, then it should be dropped).");
-    function helper5(values) {
+    assert(
+      condition === "any" || condition === "all" || condition === "none",
+      "The second parameter of the `dropMissing` method (the `condition` parameter, which indicates the condition under which data should be dropped) should be 'any' or 'all' (meaning that if 'any' of the data contains null values, then it should be dropped; or that if 'all' of the data contains null values, then it should be dropped)."
+    );
+    function helper4(values) {
       if (threshold > 0) {
         let count2 = 0;
         for (let i = 0; i < values.length; i++) {
           const value = values[i];
-          if (isUndefined(value))
-            count2++;
-          if (count2 >= threshold)
-            return [];
+          if (isUndefined(value)) count2++;
+          if (count2 >= threshold) return [];
         }
       } else if (condition === "any") {
         for (let i = 0; i < values.length; i++) {
           const value = values[i];
-          if (isUndefined(value))
-            return [];
+          if (isUndefined(value)) return [];
         }
       } else if (condition === "all") {
         for (let i = 0; i < values.length; i++) {
           const value = values[i];
-          if (!isUndefined(value))
-            return values;
+          if (!isUndefined(value)) return values;
         }
         return [];
       }
       return values;
     }
-    let out2 = df.copy();
+    let out = df.copy();
     const tempID = Math.random().toString();
     if (axis === 0) {
-      out2 = out2.assign(tempID, out2.index);
-      const newValues = out2.values.map(helper5).filter((row) => row.length > 0);
-      if (shape(newValues).length < 2)
-        return new DataFrame2();
-      out2.values = newValues;
-      let newIndex = out2.get(null, tempID);
-      if (isUndefined(newIndex))
-        return new DataFrame2();
-      if (isString(newIndex))
-        newIndex = [newIndex];
-      if (newIndex instanceof Series2)
-        newIndex = newIndex.values;
-      out2.index = newIndex;
-      out2 = out2.drop(null, tempID);
+      out = out.assign(tempID, out.index);
+      const newValues = out.values.map(helper4).filter((row) => row.length > 0);
+      if (shape(newValues).length < 2) return new DataFrame2();
+      out.values = newValues;
+      let newIndex = out.get(null, tempID);
+      if (isUndefined(newIndex)) return new DataFrame2();
+      if (isString(newIndex)) newIndex = [newIndex];
+      if (newIndex instanceof Series2) newIndex = newIndex.values;
+      out.index = newIndex;
+      out = out.drop(null, tempID);
     } else if (axis === 1) {
       const temp = {};
-      out2.columns.forEach((colName, i) => {
-        const values = out2.values.map((row) => row[i]);
-        const newValues = helper5(values);
+      out.columns.forEach((colName, i) => {
+        const values = out.values.map((row) => row[i]);
+        const newValues = helper4(values);
         if (newValues.length > 0) {
           temp[colName] = newValues;
         }
@@ -1075,90 +1163,105 @@
         return new DataFrame2();
       }
       const newOut = new DataFrame2(temp);
-      newOut.index = out2.index;
+      newOut.index = out.index;
       return newOut;
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/drop-nan.mjs
   function dropNaN(x) {
     if (isDataFrame(x) || isSeries(x)) {
       return x.dropNaN(...Object.values(arguments).slice(1));
     }
-    assert(isArray(x), "The `dropNaN` function only works on arrays, Series, and DataFrames!");
-    const out2 = [];
+    assert(
+      isArray(x),
+      "The `dropNaN` function only works on arrays, Series, and DataFrames!"
+    );
+    const out = [];
     x.forEach((v) => {
       try {
-        return out2.push(dropNaN(v));
+        return out.push(dropNaN(v));
       } catch (e) {
         if (isNumber(v)) {
-          return out2.push(v);
+          return out.push(v);
         }
       }
     });
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-drop-nan.mjs
   function dfDropNaN(DataFrame2, df, axis, condition, threshold) {
     axis = axis || 0;
-    assert(axis === 0 || axis === 1, "The first parameter of the `dropNaN` method (the `axis`) must be 0 or 1.");
+    assert(
+      axis === 0 || axis === 1,
+      "The first parameter of the `dropNaN` method (the `axis`) must be 0 or 1."
+    );
     threshold = threshold || 0;
-    assert(isWholeNumber(threshold), "The third parameter of the `dropNaN` method (the `threshold`) should be a whole number (meaning that data should be dropped if it contains more than `threshold` NaN values).");
+    assert(
+      isWholeNumber(threshold),
+      "The third parameter of the `dropNaN` method (the `threshold`) should be a whole number (meaning that data should be dropped if it contains more than `threshold` NaN values)."
+    );
     condition = threshold > 0 ? "none" : condition || "any";
-    assert(condition === "any" || condition === "all" || condition === "none", "The second parameter of the `dropNaN` method (the `condition` parameter, which indicates the condition under which data should be dropped) should be 'any' or 'all' (meaning that if 'any' of the data contains NaN values, then it should be dropped; or that if 'all' of the data contains NaN values, then it should be dropped).");
-    function helper5(values) {
+    assert(
+      condition === "any" || condition === "all" || condition === "none",
+      "The second parameter of the `dropNaN` method (the `condition` parameter, which indicates the condition under which data should be dropped) should be 'any' or 'all' (meaning that if 'any' of the data contains NaN values, then it should be dropped; or that if 'all' of the data contains NaN values, then it should be dropped)."
+    );
+    function helper4(values) {
       const numericalValues = dropNaN(values);
-      if (threshold > 0)
-        return values.length - numericalValues.length < threshold;
-      if (condition === "any")
-        return numericalValues.length === values.length;
-      if (condition === "all")
-        return numericalValues.length > 0;
+      if (threshold > 0) return values.length - numericalValues.length < threshold;
+      if (condition === "any") return numericalValues.length === values.length;
+      if (condition === "all") return numericalValues.length > 0;
       return true;
     }
-    const out2 = df.copy();
+    const out = df.copy();
     if (axis === 0) {
-      const rowsToKeep = out2.index.filter((row) => {
-        const values = out2.get(row, null).values;
-        return helper5(values);
+      const rowsToKeep = out.index.filter((row) => {
+        const values = out.get(row, null).values;
+        return helper4(values);
       });
-      if (rowsToKeep.length > 0)
-        return out2.get(rowsToKeep, null);
-      else
-        return new DataFrame2();
+      if (rowsToKeep.length > 0) return out.get(rowsToKeep, null);
+      else return new DataFrame2();
     } else if (axis === 1) {
-      const colsToKeep = out2.columns.filter((col) => {
-        const values = out2.get(null, col).values;
-        return helper5(values);
+      const colsToKeep = out.columns.filter((col) => {
+        const values = out.get(null, col).values;
+        return helper4(values);
       });
-      if (colsToKeep.length > 0)
-        return out2.get(null, colsToKeep);
-      else
-        return new DataFrame2();
+      if (colsToKeep.length > 0) return out.get(null, colsToKeep);
+      else return new DataFrame2();
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-filter.mjs
   function arrayToObject(x) {
-    const out2 = {};
+    const out = {};
     flatten(x).forEach((value, i) => {
-      out2[value] = i;
+      out[value] = i;
     });
-    return out2;
+    return out;
   }
   function undoArrayToObject(obj) {
     return Object.keys(obj).concat(Object.getOwnPropertySymbols(obj)).sort((a, b) => obj[a] - obj[b]);
   }
   function dfFilter(DataFrame2, Series2, df, fn, axis) {
-    assert(isFunction(fn), "The `filter` method takes a single parameter: a function that is used to filter the values.");
-    if (isUndefined(axis))
-      axis = 0;
-    assert(axis === 0 || axis === 1, "The `axis` parameter to the `filter` method must be 0 or 1.");
-    let out2 = df.copy();
-    if (out2.isEmpty)
-      return out2;
-    const index = arrayToObject(out2.index);
-    const columns = arrayToObject(out2.columns);
+    assert(
+      isFunction(fn),
+      "The `filter` method takes a single parameter: a function that is used to filter the values."
+    );
+    if (isUndefined(axis)) axis = 0;
+    assert(
+      axis === 0 || axis === 1,
+      "The `axis` parameter to the `filter` method must be 0 or 1."
+    );
+    let out = df.copy();
+    if (out.isEmpty) return out;
+    const index = arrayToObject(out.index);
+    const columns = arrayToObject(out.columns);
     if (axis === 0) {
       let count2 = 0;
-      const newValues = out2.values.filter((row, i) => {
+      const newValues = out.values.filter((row, i) => {
         const series = new Series2(row);
         series.name = df.index[i];
         series.index = df.columns;
@@ -1166,7 +1269,7 @@
         if (shouldKeep) {
           count2++;
         } else {
-          delete index[out2.index[i]];
+          delete index[out.index[i]];
         }
         return shouldKeep;
       });
@@ -1179,12 +1282,12 @@
         temp.index = undoArrayToObject(columns);
         return temp;
       }
-      out2.values = newValues;
-      out2.index = undoArrayToObject(index);
+      out.values = newValues;
+      out.index = undoArrayToObject(index);
     } else if (axis === 1) {
-      out2 = out2.transpose();
+      out = out.transpose();
       let count2 = 0;
-      const newValues = out2.values.filter((row, i) => {
+      const newValues = out.values.filter((row, i) => {
         const series = new Series2(row);
         series.name = df.columns[i];
         series.index = df.index;
@@ -1192,7 +1295,7 @@
         if (shouldKeep) {
           count2++;
         } else {
-          delete columns[out2.index[i]];
+          delete columns[out.index[i]];
         }
         return shouldKeep;
       });
@@ -1205,17 +1308,17 @@
         temp.index = undoArrayToObject(index);
         return temp;
       }
-      out2.values = newValues;
-      out2.index = undoArrayToObject(columns);
-      out2 = out2.transpose();
+      out.values = newValues;
+      out.index = undoArrayToObject(columns);
+      out = out.transpose();
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-get.mjs
   function dfGet(df, rows, cols) {
-    if (isString(rows) || isNumber(rows))
-      rows = [rows];
-    if (isString(cols) || isNumber(cols))
-      cols = [cols];
+    if (isString(rows) || isNumber(rows)) rows = [rows];
+    if (isString(cols) || isNumber(cols)) cols = [cols];
     for (const i in rows) {
       if (typeof rows[i] === "bigint") {
         rows[i] = Number(rows[i]);
@@ -1227,13 +1330,25 @@
       }
     }
     const types = set((rows || []).concat(cols || []).map((v) => typeof v));
-    assert(types.length <= 2, "Only whole numbers and/or strings are allowed in `get` arrays!");
+    assert(
+      types.length <= 2,
+      "Only whole numbers and/or strings are allowed in `get` arrays!"
+    );
     if (types.length === 1) {
-      assert(types[0] === "string" || types[0] === "number", "Only whole numbers and/or strings are allowed in `get` arrays!");
+      assert(
+        types[0] === "string" || types[0] === "number",
+        "Only whole numbers and/or strings are allowed in `get` arrays!"
+      );
     }
     if (types.length === 2) {
-      assert(types.indexOf("string") > -1, "Only whole numbers and/or strings are allowed in `get` arrays!");
-      assert(types.indexOf("number") > -1, "Only whole numbers and/or strings are allowed in `get` arrays!");
+      assert(
+        types.indexOf("string") > -1,
+        "Only whole numbers and/or strings are allowed in `get` arrays!"
+      );
+      assert(
+        types.indexOf("number") > -1,
+        "Only whole numbers and/or strings are allowed in `get` arrays!"
+      );
     }
     if (!isUndefined(rows)) {
       rows = rows.map((r) => {
@@ -1265,47 +1380,52 @@
     }
     return df.getSubsetByNames(rows, cols);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/sort.mjs
   function alphaSort(a, b) {
     try {
-      if (a < b)
-        return -1;
-      if (a > b)
-        return 1;
+      if (a < b) return -1;
+      if (a > b) return 1;
       return 0;
     } catch (e) {
       a = typeof a === "object" && a !== null ? JSON.stringify(a) : a.toString();
       b = typeof b === "object" && b !== null ? JSON.stringify(b) : b.toString();
-      if (a < b)
-        return -1;
-      if (a > b)
-        return 1;
+      if (a < b) return -1;
+      if (a > b) return 1;
       return 0;
     }
   }
   function sort(arr, fn) {
-    if (isUndefined(fn))
-      fn = alphaSort;
+    if (isUndefined(fn)) fn = alphaSort;
     if (isDataFrame(arr) || isSeries(arr)) {
       return arr.sort(...Object.values(arguments).slice(1));
     }
-    assert(isArray(arr), "The `sort` function only works on arrays, Series, and DataFrames!");
-    assert(isFunction(fn), "The second parameter of the `sort` function must be a comparison function!");
-    const out2 = arr.slice();
-    out2.sort(fn);
-    return out2;
+    assert(
+      isArray(arr),
+      "The `sort` function only works on arrays, Series, and DataFrames!"
+    );
+    assert(
+      isFunction(fn),
+      "The second parameter of the `sort` function must be a comparison function!"
+    );
+    const out = arr.slice();
+    out.sort(fn);
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-get-dummies.mjs
   function camelify(text) {
     const temp = text.toLowerCase();
-    let out2 = "";
+    let out = "";
     for (let i = 0; i < temp.length; i++) {
       const char = temp[i];
       if (char.match(/[a-z0-9]/g)) {
-        out2 += char;
+        out += char;
       } else {
-        out2 += " ";
+        out += " ";
       }
     }
-    const words = out2.split(" ").filter((word) => word.length > 0);
+    const words = out.split(" ").filter((word) => word.length > 0);
     return words[0] + words.slice(1).map((word) => word[0].toUpperCase() + word.substring(1)).join("");
   }
   function dfGetDummies(DataFrame2, df, columns) {
@@ -1316,9 +1436,15 @@
     }
     const temp = {};
     columns.forEach((col) => {
-      assert(isString(col), "You must pass either a string or a one-dimensional array of strings into the `getDummies` (AKA `oneHotEncode`) method!");
+      assert(
+        isString(col),
+        "You must pass either a string or a one-dimensional array of strings into the `getDummies` (AKA `oneHotEncode`) method!"
+      );
       const colIndex = df.columns.indexOf(col);
-      assert(colIndex > -1, `The given DataFrame does not have a column called "${col}"!`);
+      assert(
+        colIndex > -1,
+        `The given DataFrame does not have a column called "${col}"!`
+      );
       const values = df.values.map((row) => row[colIndex]);
       const valuesSet = sort(set(values));
       values.forEach((value) => {
@@ -1335,56 +1461,100 @@
         });
       });
     });
-    const out2 = new DataFrame2(temp);
-    out2.index = df.index;
-    return out2;
+    const out = new DataFrame2(temp);
+    out.index = df.index;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-get-subset-by-indices.mjs
   function dfGetSubsetByIndices(df, rowIndices, colIndices) {
     const dataShape = df.shape;
-    if (isUndefined(rowIndices))
-      rowIndices = range(0, dataShape[0]);
-    if (isUndefined(colIndices))
-      colIndices = range(0, dataShape[1]);
-    if (isNumber(rowIndices))
-      rowIndices = [rowIndices];
-    if (isNumber(colIndices))
-      colIndices = [colIndices];
-    assert(isArray(rowIndices) && isArray(colIndices), "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers.");
-    assert(shape(rowIndices).length === 1 && shape(colIndices).length === 1, "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers.");
-    assert(rowIndices.length > 0, "The `rowIndices` array must contain at least one index.");
-    assert(colIndices.length > 0, "The `colIndices` array must contain at least one index.");
+    if (isUndefined(rowIndices)) rowIndices = range(0, dataShape[0]);
+    if (isUndefined(colIndices)) colIndices = range(0, dataShape[1]);
+    if (isNumber(rowIndices)) rowIndices = [rowIndices];
+    if (isNumber(colIndices)) colIndices = [colIndices];
+    assert(
+      isArray(rowIndices) && isArray(colIndices),
+      "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers."
+    );
+    assert(
+      shape(rowIndices).length === 1 && shape(colIndices).length === 1,
+      "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers."
+    );
+    assert(
+      rowIndices.length > 0,
+      "The `rowIndices` array must contain at least one index."
+    );
+    assert(
+      colIndices.length > 0,
+      "The `colIndices` array must contain at least one index."
+    );
     rowIndices.forEach((rowIndex) => {
-      assert(isWholeNumber(rowIndex), "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers.");
-      assert(rowIndex < df.index.length, `The row index ${rowIndex} is out of bounds.`);
+      assert(
+        isWholeNumber(rowIndex),
+        "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers."
+      );
+      assert(
+        rowIndex < df.index.length,
+        `The row index ${rowIndex} is out of bounds.`
+      );
     });
     colIndices.forEach((colIndex) => {
-      assert(isWholeNumber(colIndex), "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers.");
-      assert(colIndex < df.columns.length, `The column index ${colIndex} is out of bounds.`);
+      assert(
+        isWholeNumber(colIndex),
+        "The `rowIndices` and `colIndices` parameters must be 1-dimensional arrays of whole numbers."
+      );
+      assert(
+        colIndex < df.columns.length,
+        `The column index ${colIndex} is out of bounds.`
+      );
     });
     const rows = rowIndices.map((i) => df.index[i]);
     const cols = colIndices.map((i) => df.columns[i]);
     return df.getSubsetByNames(rows, cols);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-get-subset-by-names.mjs
   function dfGetSubsetByNames(DataFrame2, Series2, df, rows, cols) {
-    if (isUndefined(rows))
-      rows = df.index;
-    if (isUndefined(cols))
-      cols = df.columns;
-    if (isString(rows))
-      rows = [rows];
-    if (isString(cols))
-      cols = [cols];
-    assert(isArray(rows) && isArray(cols), "The `rows` and `cols` parameters must be 1-dimensional arrays of strings.");
-    assert(shape(rows).length === 1 && shape(cols).length === 1, "The `rows` and `cols` parameters must be 1-dimensional arrays of strings.");
-    assert(rows.length > 0, "The `rows` array must contain at least one row name.");
-    assert(cols.length > 0, "The `cols` array must contain at least one column name.");
+    if (isUndefined(rows)) rows = df.index;
+    if (isUndefined(cols)) cols = df.columns;
+    if (isString(rows)) rows = [rows];
+    if (isString(cols)) cols = [cols];
+    assert(
+      isArray(rows) && isArray(cols),
+      "The `rows` and `cols` parameters must be 1-dimensional arrays of strings."
+    );
+    assert(
+      shape(rows).length === 1 && shape(cols).length === 1,
+      "The `rows` and `cols` parameters must be 1-dimensional arrays of strings."
+    );
+    assert(
+      rows.length > 0,
+      "The `rows` array must contain at least one row name."
+    );
+    assert(
+      cols.length > 0,
+      "The `cols` array must contain at least one column name."
+    );
     rows.forEach((row) => {
-      assert(isString(row), "The `rows` and `cols` parameters must be 1-dimensional arrays of strings.");
-      assert(df.index.indexOf(row) > -1, `The row name "${row}" does not exist in the list of rows.`);
+      assert(
+        isString(row),
+        "The `rows` and `cols` parameters must be 1-dimensional arrays of strings."
+      );
+      assert(
+        df.index.indexOf(row) > -1,
+        `The row name "${row}" does not exist in the list of rows.`
+      );
     });
     cols.forEach((col) => {
-      assert(isString(col), "The `rows` and `cols` parameters must be 1-dimensional arrays of strings.");
-      assert(df.columns.indexOf(col) > -1, `The column name "${col}" does not exist in the list of columns.`);
+      assert(
+        isString(col),
+        "The `rows` and `cols` parameters must be 1-dimensional arrays of strings."
+      );
+      assert(
+        df.columns.indexOf(col) > -1,
+        `The column name "${col}" does not exist in the list of columns.`
+      );
     });
     const values = rows.map((row) => {
       return cols.map((col) => {
@@ -1395,22 +1565,24 @@
       return values[0][0];
     }
     if (rows.length === 1) {
-      const out3 = new Series2(values[0]);
-      out3.name = rows[0];
-      out3.index = cols;
-      return out3;
+      const out2 = new Series2(values[0]);
+      out2.name = rows[0];
+      out2.index = cols;
+      return out2;
     }
     if (cols.length === 1) {
-      const out3 = new Series2(values.map((v) => v[0]));
-      out3.name = cols[0];
-      out3.index = rows;
-      return out3;
-    }
-    const out2 = new DataFrame2(values);
-    out2.columns = cols;
-    out2.index = rows;
-    return out2;
+      const out2 = new Series2(values.map((v) => v[0]));
+      out2.name = cols[0];
+      out2.index = rows;
+      return out2;
+    }
+    const out = new DataFrame2(values);
+    out.columns = cols;
+    out.index = rows;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-print.mjs
   function dfPrint(DataFrame2, Series2, df) {
     function truncate(s2, maxLength2) {
       if (isString(s2)) {
@@ -1430,10 +1602,14 @@
     }
     const maxRows = typeof window === "undefined" ? 20 : 10;
     const halfMaxRows = Math.floor(maxRows / 2);
-    const maxColumns = typeof process === "undefined" ? 10 : Math.floor(process.stdout.columns / 24) - 1;
+    const maxColumns = 4;
     const halfMaxColumns = Math.floor(maxColumns / 2);
-    const tempRows = maxRows > df.index.length ? null : range(0, halfMaxRows).concat(range(df.index.length - halfMaxRows, df.index.length));
-    const tempColumns = maxColumns > df.columns.length ? null : range(0, halfMaxColumns).concat(range(df.columns.length - halfMaxColumns, df.columns.length));
+    const tempRows = maxRows > df.index.length ? null : range(0, halfMaxRows).concat(
+      range(df.index.length - halfMaxRows, df.index.length)
+    );
+    const tempColumns = maxColumns > df.columns.length ? null : range(0, halfMaxColumns).concat(
+      range(df.columns.length - halfMaxColumns, df.columns.length)
+    );
     let temp = df.get(tempRows, tempColumns);
     if (temp instanceof Series2) {
       if (df.shape[0] === 1) {
@@ -1448,7 +1624,11 @@
     }
     if (maxRows <= df.index.length) {
       temp._index.splice(halfMaxRows, 0, "...");
-      temp._values.splice(halfMaxRows, 0, range(0, temp.columns.length).map(() => "..."));
+      temp._values.splice(
+        halfMaxRows,
+        0,
+        range(0, temp.columns.length).map(() => "...")
+      );
     }
     if (maxColumns <= df.columns.length) {
       temp._columns.splice(halfMaxColumns, 0, "...");
@@ -1473,31 +1653,38 @@
     console.log("Shape:", df.shape, "\n");
     return df;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/helpers/left-pad.mjs
   function leftPad(x, maxLength) {
     assert(isNumber(x), "The `leftPad` function only works on numbers!");
-    let out2 = x.toString();
-    while (out2.length < maxLength)
-      out2 = "0" + out2;
-    return out2;
+    let out = x.toString();
+    while (out.length < maxLength) out = "0" + out;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-reset-index.mjs
   function dfResetIndex(df, shouldSkipCopying) {
-    const out2 = shouldSkipCopying ? df : df.copy();
-    out2.index = range(0, df.shape[0]).map((i) => {
-      return "row" + leftPad(i, (out2.index.length - 1).toString().length);
+    const out = shouldSkipCopying ? df : df.copy();
+    out.index = range(0, df.shape[0]).map((i) => {
+      return "row" + leftPad(i, (out.index.length - 1).toString().length);
     });
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/product.mjs
   function product(arr, shouldDropNaNs) {
     if (isDataFrame(arr) || isSeries(arr)) {
       return product(arr.values, shouldDropNaNs);
     }
-    assert(isArray(arr), "The `product` function only works on arrays, Series, and DataFrames!");
+    assert(
+      isArray(arr),
+      "The `product` function only works on arrays, Series, and DataFrames!"
+    );
     try {
-      if (arr.length === 0)
-        return NaN;
+      if (arr.length === 0) return NaN;
       const temp = flatten(arr);
       let resultShouldBeABigInt = false;
-      let out2 = 1;
+      let out = 1;
       for (let v of temp) {
         if (!isNumber(v)) {
           if (shouldDropNaNs) {
@@ -1510,36 +1697,51 @@
           resultShouldBeABigInt = true;
           v = Number(v);
         }
-        out2 *= v;
+        out *= v;
       }
       if (resultShouldBeABigInt) {
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
         }
       }
-      return out2;
+      return out;
     } catch (e) {
       return NaN;
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/helpers/is-natural-number.mjs
   function isNaturalNumber(x) {
     return isInteger(x) && x > 0;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/reshape.mjs
   function reshape(x, newShape) {
     if (isDataFrame(x) || isSeries(x)) {
       return reshape(x.values, newShape);
     }
-    assert(isArray(x), "The first argument passed into the `reshape` function must be an array!");
-    if (isNumber(newShape))
-      newShape = [newShape];
-    assert(isArray(newShape), "The second argument passed into the `reshape` function must be a whole number or a one-dimensional array of whole numbers!");
-    assert(shape(newShape).length === 1, "The first argument passed into the `reshape` function must be a whole number or a one-dimensional array of whole numbers!");
+    assert(
+      isArray(x),
+      "The first argument passed into the `reshape` function must be an array!"
+    );
+    if (isNumber(newShape)) newShape = [newShape];
+    assert(
+      isArray(newShape),
+      "The second argument passed into the `reshape` function must be a whole number or a one-dimensional array of whole numbers!"
+    );
+    assert(
+      shape(newShape).length === 1,
+      "The first argument passed into the `reshape` function must be a whole number or a one-dimensional array of whole numbers!"
+    );
     newShape = newShape.map((v) => {
       if (typeof v === "bigint") {
         v = Number(v);
       }
-      assert(isNaturalNumber(v), "The first argument passed into the `reshape` function must be a whole number or a one-dimensional array of whole numbers!");
+      assert(
+        isNaturalNumber(v),
+        "The first argument passed into the `reshape` function must be a whole number or a one-dimensional array of whole numbers!"
+      );
       return Number(v);
     });
     if (newShape.length === 0) {
@@ -1549,31 +1751,35 @@
     if (newShape.length === 1 && newShape[0] === temp.length) {
       return temp;
     }
-    assert(product(newShape) === temp.length, "The new shape doesn't match the number of values available in `x` (the first argument passed into the `reshape` function)!");
-    const out2 = [];
+    assert(
+      product(newShape) === temp.length,
+      "The new shape doesn't match the number of values available in `x` (the first argument passed into the `reshape` function)!"
+    );
+    const out = [];
     const step = Math.floor(temp.length / newShape[0]);
     for (let i = 0; i < newShape[0]; i++) {
       const row = temp.slice(i * step, (i + 1) * step);
-      out2.push(reshape(row, newShape.slice(1)));
+      out.push(reshape(row, newShape.slice(1)));
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/random.mjs
   var MAX = Math.pow(2, 64);
   var s = [];
   seed(Math.floor(Math.random() * MAX));
   function splitmix64(state, n) {
     state = uint(state);
-    function helper5() {
+    function helper4() {
       state += uint("0x9e3779b97f4a7c15");
       let z = copy(state);
       z = (z ^ z >> BigInt(30)) * uint("0xbf58476d1ce4e5b9");
       z = (z ^ z >> BigInt(27)) * uint("0x94d049bb133111eb");
       return z ^ z >> BigInt(31);
     }
-    const out2 = [];
-    for (let i = 0; i < n; i++)
-      out2.push(helper5());
-    return out2;
+    const out = [];
+    for (let i = 0; i < n; i++) out.push(helper4());
+    return out;
   }
   function uint(x) {
     return BigInt.asUintN(64, BigInt(x));
@@ -1588,7 +1794,10 @@
       val = Number(val);
     }
     if (!isUndefined(val)) {
-      assert(isNumber(val), "If passing a value into the `seed` function, then that value must be an integer!");
+      assert(
+        isNumber(val),
+        "If passing a value into the `seed` function, then that value must be an integer!"
+      );
       const temp = splitmix64(Math.floor(val), 4);
       s[0] = temp[0];
       s[1] = temp[1];
@@ -1610,34 +1819,48 @@
     return Math.floor(Number(result)) / MAX;
   }
   function random(shape2) {
-    if (isUndefined(shape2))
-      return next();
-    if (!isArray(shape2))
-      shape2 = [shape2];
+    if (isUndefined(shape2)) return next();
+    if (!isArray(shape2)) shape2 = [shape2];
     return reshape(ndarray(product(shape2)).map(next), shape2);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/shuffle.mjs
   function shuffle(arr) {
     if (isDataFrame(arr) || isSeries(arr)) {
       return arr.shuffle(...Object.values(arguments).slice(1));
     }
-    assert(isArray(arr), "The `shuffle` function only works on arrays, Series, and DataFrames!");
-    const out2 = [];
+    assert(
+      isArray(arr),
+      "The `shuffle` function only works on arrays, Series, and DataFrames!"
+    );
+    const out = [];
     const temp = arr.slice();
     for (let i = 0; i < arr.length; i++) {
       const index = Math.floor(random() * temp.length);
-      out2.push(temp.splice(index, 1)[0]);
+      out.push(temp.splice(index, 1)[0]);
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-shuffle.mjs
   function dfShuffle(df, axis) {
-    if (isUndefined(axis))
-      axis = 0;
-    assert(axis === 0 || axis === 1, "The `axis` parameter to the `shuffle` must be 0, 1, or undefined.");
-    return df.get(axis === 0 ? shuffle(df.index) : null, axis === 1 ? shuffle(df.columns) : null);
+    if (isUndefined(axis)) axis = 0;
+    assert(
+      axis === 0 || axis === 1,
+      "The `axis` parameter to the `shuffle` must be 0, 1, or undefined."
+    );
+    return df.get(
+      axis === 0 ? shuffle(df.index) : null,
+      axis === 1 ? shuffle(df.columns) : null
+    );
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/is-boolean.mjs
   function isBoolean(x) {
     return typeof x === "boolean";
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-sort.mjs
   function dfSort(df, a, b) {
     if (isFunction(a)) {
       return dfSortByFunction(df, a, b);
@@ -1647,8 +1870,14 @@
   }
   function dfSortByFunction(df, fn, axis) {
     axis = isUndefined(axis) ? 0 : axis;
-    assert(isFunction(fn), "When sorting a DataFrame using a function, the first argument to the `sort` method must be a function!");
-    assert(isNumber(axis), "When sorting a DataFrame using a function, the second argument to the `sort` method must be null, undefined, 0, or 1 to indicate the axis along which the data should be sorted! An axis of 0 means that the rows will be sorted relative to each other, whereas an axis of 1 means that the columns will be sorted relative to each other.");
+    assert(
+      isFunction(fn),
+      "When sorting a DataFrame using a function, the first argument to the `sort` method must be a function!"
+    );
+    assert(
+      isNumber(axis),
+      "When sorting a DataFrame using a function, the second argument to the `sort` method must be null, undefined, 0, or 1 to indicate the axis along which the data should be sorted! An axis of 0 means that the rows will be sorted relative to each other, whereas an axis of 1 means that the columns will be sorted relative to each other."
+    );
     if (axis === 0) {
       const index = sort(df.index, (a, b) => {
         return fn(df.get(a, null), df.get(b, null));
@@ -1662,81 +1891,106 @@
     }
   }
   function dfSortByColumns(df, cols, directions) {
-    let out2 = df.copy();
+    let out = df.copy();
     const indexID = random().toString();
-    out2 = out2.assign(indexID, out2.index);
+    out = out.assign(indexID, out.index);
     if (isUndefined(cols)) {
       cols = [indexID];
       directions = [true];
     }
     if (isNumber(cols) || isString(cols)) {
       cols = [cols];
-      if (isBoolean(directions) || isString(directions))
-        directions = [directions];
+      if (isBoolean(directions) || isString(directions)) directions = [directions];
     }
-    assert(isArray(cols), "The first parameter of the `sort` method must be (1) a string or index representing a column name or index, respectively; (2) a 1-dimensional array of strings and/or indices; or (3) null.");
-    assert(shape(cols).length === 1, "The first parameter of the `sort` method must be (1) a string or index representing a column name or index, respectively; (2) a 1-dimensional array of strings and/or indices; or (3) null.");
+    assert(
+      isArray(cols),
+      "The first parameter of the `sort` method must be (1) a string or index representing a column name or index, respectively; (2) a 1-dimensional array of strings and/or indices; or (3) null."
+    );
+    assert(
+      shape(cols).length === 1,
+      "The first parameter of the `sort` method must be (1) a string or index representing a column name or index, respectively; (2) a 1-dimensional array of strings and/or indices; or (3) null."
+    );
     if (isUndefined(directions))
       directions = range(0, cols.length).map(() => true);
-    assert(isArray(directions), "The second parameter of the `sort` method must be (1) a string or boolean representing the sort direction ('ascending' / 'descending', or true / false); (2) a 1-dimensional array of strings and/or booleans; or (3) null.");
-    assert(shape(directions).length === 1, "The second parameter of the `sort` method must be (1) a string or boolean representing the sort direction ('ascending' / 'descending', or true / false); (2) a 1-dimensional array of strings and/or booleans; or (3) null.");
-    assert(cols.length === directions.length, "The arrays passed into the `sort` method must be equal in length.");
+    assert(
+      isArray(directions),
+      "The second parameter of the `sort` method must be (1) a string or boolean representing the sort direction ('ascending' / 'descending', or true / false); (2) a 1-dimensional array of strings and/or booleans; or (3) null."
+    );
+    assert(
+      shape(directions).length === 1,
+      "The second parameter of the `sort` method must be (1) a string or boolean representing the sort direction ('ascending' / 'descending', or true / false); (2) a 1-dimensional array of strings and/or booleans; or (3) null."
+    );
+    assert(
+      cols.length === directions.length,
+      "The arrays passed into the `sort` method must be equal in length."
+    );
     cols = cols.map((col) => {
-      assert(isString(col) || isNumber(col), "Column references can either be column names (as strings) or column indices (as whole numbers).");
+      assert(
+        isString(col) || isNumber(col),
+        "Column references can either be column names (as strings) or column indices (as whole numbers)."
+      );
       if (isString(col)) {
-        const index = out2.columns.indexOf(col);
+        const index = out.columns.indexOf(col);
         assert(index > -1, `The column "${col}" does not exist!`);
         return index;
       }
       if (isNumber(col)) {
         assert(isWholeNumber(col), "Column indices must be whole numbers!");
-        assert(col < out2.columns.length, `The index ${col} is out of bounds!`);
+        assert(col < out.columns.length, `The index ${col} is out of bounds!`);
         return col;
       }
     });
     directions = directions.map((dir) => {
-      assert(isString(dir) || isBoolean(dir), "Direction references can either be strings ('ascending' or 'descending') or booleans (true or false).");
+      assert(
+        isString(dir) || isBoolean(dir),
+        "Direction references can either be strings ('ascending' or 'descending') or booleans (true or false)."
+      );
       if (isString(dir)) {
         const value = dir.trim().toLowerCase();
-        assert(value === "ascending" || value === "descending", "Direction references can either be strings ('ascending' or 'descending') or booleans (true or false).");
+        assert(
+          value === "ascending" || value === "descending",
+          "Direction references can either be strings ('ascending' or 'descending') or booleans (true or false)."
+        );
         return value === "ascending";
       }
       if (isBoolean(dir)) {
         return dir;
       }
     });
-    out2.values = sort(out2.values, (a, b) => {
+    out.values = sort(out.values, (a, b) => {
       let counter = 0;
       while (a[cols[counter]] === b[cols[counter]] && counter < cols.length) {
         counter++;
       }
       const isAscending = directions[counter];
-      if (a[cols[counter]] === b[cols[counter]])
-        return 0;
-      if (a[cols[counter]] < b[cols[counter]])
-        return isAscending ? -1 : 1;
-      if (a[cols[counter]] > b[cols[counter]])
-        return isAscending ? 1 : -1;
+      if (a[cols[counter]] === b[cols[counter]]) return 0;
+      if (a[cols[counter]] < b[cols[counter]]) return isAscending ? -1 : 1;
+      if (a[cols[counter]] > b[cols[counter]]) return isAscending ? 1 : -1;
     });
-    const indexNumber = out2.columns.indexOf(indexID);
-    out2.index = out2.values.map((row) => row[indexNumber]);
-    out2 = out2.dropColumns(indexID);
-    return out2;
+    const indexNumber = out.columns.indexOf(indexID);
+    out.index = out.values.map((row) => row[indexNumber]);
+    out = out.dropColumns(indexID);
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-to-detailed-object.mjs
   function dfToDetailedObject(df, axis) {
     if (isUndefined(axis)) {
       axis = 0;
     } else {
-      assert(axis === 0 || axis === 1, "The axis parameter of the `toDetailedObject` method must be undefined, 0, or 1. An axis of 0 indicates that the returned object should be organized first by rows and then by columns. An axis of 1 indicates that the returned object should be organized first by columns and then by rows.");
+      assert(
+        axis === 0 || axis === 1,
+        "The axis parameter of the `toDetailedObject` method must be undefined, 0, or 1. An axis of 0 indicates that the returned object should be organized first by rows and then by columns. An axis of 1 indicates that the returned object should be organized first by columns and then by rows."
+      );
     }
-    const out2 = {};
+    const out = {};
     if (axis === 0) {
       df.index.forEach((rowName, i) => {
         const temp = {};
         df.columns.forEach((colName, j) => {
           temp[colName] = df.values[i][j];
         });
-        out2[rowName] = temp;
+        out[rowName] = temp;
       });
     } else {
       df.columns.forEach((colName, j) => {
@@ -1744,114 +1998,107 @@
         df.index.forEach((rowName, i) => {
           temp[rowName] = df.values[i][j];
         });
-        out2[colName] = temp;
+        out[colName] = temp;
       });
     }
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-to-json-string.mjs
   function dfToJSONString(df, axis) {
     return JSON.stringify(df.toObject(axis));
   }
-  async function dfToJSON(df, filename, axis) {
-    const out2 = dfToJSONString(df, axis);
-    let downloadedInBrowser = false;
-    let wroteToDiskInNode = false;
-    let browserError, nodeError;
-    try {
-      let newFilename = filename;
-      if (filename.includes("/")) {
-        const parts = filename.split("/");
-        newFilename = parts[parts.length - 1];
-      }
-      const a = document.createElement("a");
-      a.href = `data:application/json;charset=utf-8,${encodeURIComponent(out2)}`;
-      a.download = newFilename;
-      a.dispatchEvent(new MouseEvent("click"));
-      downloadedInBrowser = true;
-    } catch (e) {
-      browserError = e;
-    }
-    try {
-      const fs = await import("node:fs");
-      const path = await import("node:path");
-      fs.writeFileSync(path.resolve(filename), out2, "utf8");
-      wroteToDiskInNode = true;
-    } catch (e) {
-      nodeError = e;
-    }
-    if (!downloadedInBrowser && !wroteToDiskInNode) {
-      if (typeof window !== "undefined") {
-        throw new MathError(browserError);
-      } else if (typeof module !== "undefined") {
-        throw new MathError(nodeError);
-      } else {
-        throw new MathError("I don't know what's going wrong, but it doesn't seem like you're in Node or the browser, and we couldn't download and/or write the file to disk!");
-      }
-    }
-    return df;
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-to-json.mjs
+  async function dfToJSON(df, axis) {
+    return JSON.parse(dfToJSONString(df, axis));
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/df-to-object.mjs
   function dfToObject(df) {
-    const out2 = {};
+    const out = {};
     df.columns.forEach((col) => {
-      out2[col] = df.get(col).values;
+      out[col] = df.get(col).values;
     });
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/transpose.mjs
   function transpose(arr) {
     if (isDataFrame(arr) || isSeries(arr)) {
       return arr.transpose();
     }
-    assert(isArray(arr), "The `transpose` function only works on arrays, Series, and DataFrames!");
+    assert(
+      isArray(arr),
+      "The `transpose` function only works on arrays, Series, and DataFrames!"
+    );
     const theShape = shape(arr);
-    assert(theShape.length <= 2, "I'm not smart enough to know how to transpose arrays that have more than 2 dimensions. Sorry for the inconvenience! Please only pass 1- or 2-dimensional arrays into the `transpose` function!");
+    assert(
+      theShape.length <= 2,
+      "I'm not smart enough to know how to transpose arrays that have more than 2 dimensions. Sorry for the inconvenience! Please only pass 1- or 2-dimensional arrays into the `transpose` function!"
+    );
     if (theShape.length === 1) {
       return reverse(arr);
     } else if (theShape.length === 2) {
-      const out2 = ndarray(reverse(theShape));
+      const out = ndarray(reverse(theShape));
       for (let row = 0; row < theShape[0]; row++) {
         for (let col = 0; col < theShape[1]; col++) {
-          out2[col][row] = arr[row][col];
+          out[col][row] = arr[row][col];
         }
       }
-      return out2;
+      return out;
     }
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-append.mjs
   function seriesAppend(Series2, series, x) {
     if (isSeries(x)) {
       return new Series2(series.values.concat(x.values));
     }
     if (isArray(x)) {
       const xShape = shape(x);
-      assert(xShape.length === 1 && !isNested(xShape), "Only vectors can be appended to Series!");
-      const out2 = series.copy();
+      assert(
+        xShape.length === 1 && !isNested(xShape),
+        "Only vectors can be appended to Series!"
+      );
+      const out = series.copy();
       x.forEach((v, i) => {
-        out2._values.push(v);
-        out2._index.push("item" + (series.values.length + i));
+        out._values.push(v);
+        out._index.push("item" + (series.values.length + i));
       });
-      return out2;
+      return out;
     }
     return seriesAppend(series, [x]);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-apply.mjs
   function seriesApply(series, fn) {
-    assert(isFunction(fn), "The parameter to the `apply` method must be a function.");
-    const out2 = series.copy();
-    out2._values = out2._values.map((v, i) => fn(v, i));
-    return out2;
+    assert(
+      isFunction(fn),
+      "The parameter to the `apply` method must be a function."
+    );
+    const out = series.copy();
+    out._values = out._values.map((v, i) => fn(v, i));
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-drop-missing.mjs
   function seriesDropMissing(series) {
-    const out2 = series.copy();
+    const out = series.copy();
     const outIndex = [];
-    out2._values = out2.values.filter((v, i) => {
+    out._values = out.values.filter((v, i) => {
       if (isUndefined(v)) {
         return false;
       } else {
-        outIndex.push(out2.index[i]);
+        outIndex.push(out.index[i]);
         return true;
       }
     });
-    out2._index = outIndex;
-    return out2;
+    out._index = outIndex;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-drop-nan.mjs
   function seriesDropNaN(Series2, series) {
     const index = [];
     const values = [];
@@ -1861,49 +2108,63 @@
         index.push(series.index[i]);
       }
     });
-    const out2 = new Series2(values);
-    out2.name = series.name;
-    out2.index = index;
-    return out2;
+    const out = new Series2(values);
+    out.name = series.name;
+    out.index = index;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-filter.mjs
   function seriesFilter(Series2, series, fn) {
-    let out2 = series.copy();
-    const index = copy(out2.index);
+    let out = series.copy();
+    const index = copy(out.index);
     const indicesToRemove = [];
-    const newValues = out2.values.filter((value, i) => {
-      const shouldKeep = fn(value, i, out2.values);
-      if (!shouldKeep)
-        indicesToRemove.push(out2.index[i]);
+    const newValues = out.values.filter((value, i) => {
+      const shouldKeep = fn(value, i, out.values);
+      if (!shouldKeep) indicesToRemove.push(out.index[i]);
       return shouldKeep;
     });
     indicesToRemove.forEach((i) => {
       index.splice(index.indexOf(i), 1);
     });
     if (newValues.length === 0) {
-      out2 = new Series2();
-      out2.name = series.name;
-      return out2;
+      out = new Series2();
+      out.name = series.name;
+      return out;
     }
-    out2.values = newValues;
-    out2.index = index;
-    return out2;
+    out.values = newValues;
+    out.index = index;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-get.mjs
   function seriesGet(series, indices) {
-    if (isString(indices) || isNumber(indices))
-      indices = [indices];
+    if (isString(indices) || isNumber(indices)) indices = [indices];
     for (const i in indices) {
       if (typeof indices[i] === "bigint") {
         indices[i] = Number(indices[i]);
       }
     }
     const types = set((indices || []).map((v) => typeof v));
-    assert(types.length <= 2, "Only whole numbers and/or strings are allowed in `get` arrays!");
+    assert(
+      types.length <= 2,
+      "Only whole numbers and/or strings are allowed in `get` arrays!"
+    );
     if (types.length === 1) {
-      assert(types[0] === "string" || types[0] === "number", "Only whole numbers and/or strings are allowed in `get` arrays!");
+      assert(
+        types[0] === "string" || types[0] === "number",
+        "Only whole numbers and/or strings are allowed in `get` arrays!"
+      );
     }
     if (types.length === 2) {
-      assert(types.indexOf("string") > -1, "Only whole numbers and/or strings are allowed in `get` arrays!");
-      assert(types.indexOf("number") > -1, "Only whole numbers and/or strings are allowed in `get` arrays!");
+      assert(
+        types.indexOf("string") > -1,
+        "Only whole numbers and/or strings are allowed in `get` arrays!"
+      );
+      assert(
+        types.indexOf("number") > -1,
+        "Only whole numbers and/or strings are allowed in `get` arrays!"
+      );
     }
     if (!isUndefined(indices)) {
       indices = indices.map((i) => {
@@ -1921,68 +2182,109 @@
     }
     return series.getSubsetByNames(indices);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-get-subset-by-indices.mjs
   function seriesGetSubsetByIndices(series, indices) {
     const dataShape = series.shape;
-    if (isUndefined(indices))
-      indices = range(0, dataShape[0]);
-    assert(isArray(indices), "The `indices` array must be 1-dimensional array of whole numbers.");
-    assert(shape(indices).length === 1, "The `indices` array must be a 1-dimensional array of whole numbers.");
-    assert(indices.length > 0, "The `indices` array must contain at least one index.");
+    if (isUndefined(indices)) indices = range(0, dataShape[0]);
+    assert(
+      isArray(indices),
+      "The `indices` array must be 1-dimensional array of whole numbers."
+    );
+    assert(
+      shape(indices).length === 1,
+      "The `indices` array must be a 1-dimensional array of whole numbers."
+    );
+    assert(
+      indices.length > 0,
+      "The `indices` array must contain at least one index."
+    );
     indices.forEach((index) => {
-      assert(isWholeNumber(index), "The `indices` array must be a 1-dimensional array of whole numbers.");
-      assert(index < series.index.length, `The row index ${index} is out of bounds.`);
+      assert(
+        isWholeNumber(index),
+        "The `indices` array must be a 1-dimensional array of whole numbers."
+      );
+      assert(
+        index < series.index.length,
+        `The row index ${index} is out of bounds.`
+      );
     });
     const rows = indices.map((i) => series.index[i]);
     return series.getSubsetByNames(rows);
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-get-subset-by-names.mjs
   function seriesGetSubsetByNames(Series2, series, indices) {
-    if (isUndefined(indices))
-      indices = series.index;
-    assert(isArray(indices), "The `indices` array must be a 1-dimensional array of strings.");
-    assert(shape(indices).length === 1, "The `indices` array must be a 1-dimensional array of strings.");
-    assert(indices.length > 0, "The `indices` array must contain at least one index name.");
+    if (isUndefined(indices)) indices = series.index;
+    assert(
+      isArray(indices),
+      "The `indices` array must be a 1-dimensional array of strings."
+    );
+    assert(
+      shape(indices).length === 1,
+      "The `indices` array must be a 1-dimensional array of strings."
+    );
+    assert(
+      indices.length > 0,
+      "The `indices` array must contain at least one index name."
+    );
     indices.forEach((name) => {
       assert(isString(name), "The `indices` array must contain only strings.");
-      assert(series.index.indexOf(name) > -1, `The name "${name}" does not exist in the index.`);
+      assert(
+        series.index.indexOf(name) > -1,
+        `The name "${name}" does not exist in the index.`
+      );
     });
     const values = indices.map((name) => {
       return series.values[series.index.indexOf(name)];
     });
-    if (values.length === 1)
-      return values[0];
-    const out2 = new Series2(values);
-    out2.index = indices;
-    out2.name = series.name;
-    return out2;
+    if (values.length === 1) return values[0];
+    const out = new Series2(values);
+    out.index = indices;
+    out.name = series.name;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-print.mjs
   function seriesPrint(series) {
     let temp = series.copy();
     const maxRows = typeof window === "undefined" ? 20 : 10;
     if (temp.index.length > maxRows) {
-      temp = temp.get(range(0, maxRows / 2).concat(range(temp.index.length - maxRows / 2, temp.index.length)));
+      temp = temp.get(
+        range(0, maxRows / 2).concat(
+          range(temp.index.length - maxRows / 2, temp.index.length)
+        )
+      );
       const tempIndex = copy(temp.index);
       tempIndex.splice(Math.floor(tempIndex.length / 2), 0, "...");
       temp.values.push("...");
       temp.index.push("...");
       temp = temp.get(tempIndex);
     }
-    const out2 = {};
+    const out = {};
     temp.values.forEach((value, i) => {
       const obj = {};
       obj[temp.name] = value;
-      out2[temp.index[i]] = obj;
+      out[temp.index[i]] = obj;
     });
-    console.table(out2);
+    console.table(out);
     console.log("Shape:", series.shape, "\n");
     return series;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-shuffle.mjs
   function seriesShuffle(series) {
-    const out2 = series.copy();
-    return out2.get(shuffle(out2.index));
+    const out = series.copy();
+    return out.get(shuffle(out.index));
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-sort.mjs
   function seriesSort(Series2, series, fn) {
     fn = fn || ((a, b) => a < b ? -1 : 1);
-    assert(isUndefined(fn) || isFunction(fn), "You must pass undefined, null, or a comparison function as the second argument to the `sort` method!");
+    assert(
+      isUndefined(fn) || isFunction(fn),
+      "You must pass undefined, null, or a comparison function as the second argument to the `sort` method!"
+    );
     const pairs = transpose([series.values, series.index]);
     const temp = sort(pairs, (aPair, bPair) => {
       return fn(aPair[0], bPair[0]);
@@ -1993,35 +2295,40 @@
       newValues.push(pair[0]);
       newIndex.push(pair[1]);
     });
-    const out2 = new Series2();
-    out2._values = newValues;
-    out2._index = newIndex;
-    out2.name = series.name;
-    return out2;
+    const out = new Series2();
+    out._values = newValues;
+    out._index = newIndex;
+    out.name = series.name;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-sort-by-index.mjs
   function seriesSortByIndex(Series2, series) {
     let temp = transpose([series.values, series.index]);
-    temp = transpose(sort(temp, (a, b) => {
-      if (a[1] === b[1])
-        return 0;
-      if (a[1] < b[1])
-        return -1;
-      if (a[1] > b[1])
-        return 1;
-    }));
-    const out2 = new Series2(temp[0]);
-    out2.index = temp[1];
-    out2.name = series.name;
-    return out2;
+    temp = transpose(
+      sort(temp, (a, b) => {
+        if (a[1] === b[1]) return 0;
+        if (a[1] < b[1]) return -1;
+        if (a[1] > b[1]) return 1;
+      })
+    );
+    const out = new Series2(temp[0]);
+    out.index = temp[1];
+    out.name = series.name;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/series-to-object.mjs
   function seriesToObject(series) {
-    const out2 = {};
-    out2[series.name] = {};
+    const out = {};
+    out[series.name] = {};
     series.index.forEach((index, i) => {
-      out2[series.name][index] = series.values[i];
+      out[series.name][index] = series.values[i];
     });
-    return out2;
+    return out;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/series/index.mjs
   var SERIES_SYMBOL = Symbol.for("@jrc03c/js-math-tools/series");
   function createSeriesClass(DataFrame2) {
     class Series2 {
@@ -2055,13 +2362,18 @@
           set(x) {
             assert(isArray(x), "The new values must be a 1-dimensional array!");
             const dataShape = shape(x);
-            assert(dataShape.length === 1, "The new array of values must be 1-dimensional!");
+            assert(
+              dataShape.length === 1,
+              "The new array of values must be 1-dimensional!"
+            );
             if (dataShape[0] < this._index.length) {
               this._index = this._index.slice(0, dataShape[0]);
             } else if (dataShape[0] > this._index.length) {
-              this._index = this._index.concat(range(this._index.length, dataShape[0]).map((i) => {
-                return "item" + leftPad(i, (x.length - 1).toString().length);
-              }));
+              this._index = this._index.concat(
+                range(this._index.length, dataShape[0]).map((i) => {
+                  return "item" + leftPad(i, (x.length - 1).toString().length);
+                })
+              );
             }
             this._values = x;
           }
@@ -2079,9 +2391,18 @@
             return this._index;
           },
           set(x) {
-            assert(isArray(x), "The new index must be a 1-dimensional array of strings!");
-            assert(x.length === this.shape[0], "The new index must be the same length as the old index!");
-            assert(shape(x).length === 1, "The new index must be a 1-dimensional array of strings!");
+            assert(
+              isArray(x),
+              "The new index must be a 1-dimensional array of strings!"
+            );
+            assert(
+              x.length === this.shape[0],
+              "The new index must be the same length as the old index!"
+            );
+            assert(
+              shape(x).length === 1,
+              "The new index must be a 1-dimensional array of strings!"
+            );
             x.forEach((value) => {
               assert(isString(value), "All of the row names must be strings!");
             });
@@ -2095,14 +2416,23 @@
             this.index = copy(data.index);
           } else if (isArray(data)) {
             const dataShape = shape(data);
-            assert(dataShape.length === 1, "When passing an array into the constructor of a Series, the array must be 1-dimensional!");
+            assert(
+              dataShape.length === 1,
+              "When passing an array into the constructor of a Series, the array must be 1-dimensional!"
+            );
             this.values = data;
           } else if (data instanceof Object) {
             const keys = Object.keys(data).concat(Object.getOwnPropertySymbols(data)).map((v) => v.toString());
-            assert(keys.length === 1, "When passing an object into the constructor of a Series, the object must have only 1 key-value pair, where the key is the name of the data and the value is the 1-dimensional array of values!");
+            assert(
+              keys.length === 1,
+              "When passing an object into the constructor of a Series, the object must have only 1 key-value pair, where the key is the name of the data and the value is the 1-dimensional array of values!"
+            );
             const name = keys[0];
             const values = data[name];
-            assert(shape(values).length === 1, "When passing an object into the constructor of a Series, the object must have only 1 key-value pair, where the key is the name of the data and the value is the 1-dimensional array of values!");
+            assert(
+              shape(values).length === 1,
+              "When passing an object into the constructor of a Series, the object must have only 1 key-value pair, where the key is the name of the data and the value is the 1-dimensional array of values!"
+            );
             this.name = name;
             this.values = values.slice();
           }
@@ -2118,11 +2448,11 @@
         return this.values.filter((v) => !isUndefined(v)).length === 0;
       }
       clear() {
-        const out2 = this.copy();
-        out2.values.forEach((v, i) => {
-          out2.values[i] = void 0;
+        const out = this.copy();
+        out.values.forEach((v, i) => {
+          out.values[i] = void 0;
         });
-        return out2;
+        return out;
       }
       get(indices) {
         return seriesGet(this, indices);
@@ -2140,24 +2470,24 @@
         return this.getSubsetByIndices(indices);
       }
       reverse() {
-        const out2 = new Series2(reverse(this.values));
-        out2.index = reverse(this.index);
-        out2.name = this.name;
-        return out2;
+        const out = new Series2(reverse(this.values));
+        out.index = reverse(this.index);
+        out.name = this.name;
+        return out;
       }
       resetIndex() {
-        const out2 = this.copy();
-        out2.index = range(0, this.shape[0]).map((i) => {
-          return "item" + leftPad(i, (out2.index.length - 1).toString().length);
+        const out = this.copy();
+        out.index = range(0, this.shape[0]).map((i) => {
+          return "item" + leftPad(i, (out.index.length - 1).toString().length);
         });
-        return out2;
+        return out;
       }
       copy() {
-        const out2 = new Series2();
-        out2._values = copy(this.values);
-        out2._index = copy(this.index);
-        out2.name = this.name;
-        return out2;
+        const out = new Series2();
+        out._values = copy(this.values);
+        out._index = copy(this.index);
+        out.name = this.name;
+        return out;
       }
       append(x) {
         return seriesAppend(Series2, this, x);
@@ -2193,16 +2523,16 @@
         return seriesFilter(Series2, this, fn);
       }
       toDataFrame() {
-        const out2 = new DataFrame2(transpose([this.values]));
-        out2.columns = [this.name];
-        out2.index = this.index;
-        return out2;
+        const out = new DataFrame2(transpose([this.values]));
+        out.columns = [this.name];
+        out.index = this.index;
+        return out;
       }
       transpose() {
-        const out2 = this.copy();
-        out2.values = reverse(out2.values);
-        out2.index = reverse(out2.index);
-        return out2;
+        const out = this.copy();
+        out.values = reverse(out.values);
+        out.index = reverse(out.index);
+        return out;
       }
       getDummies() {
         return this.toDataFrame().getDummies();
@@ -2213,15 +2543,16 @@
     }
     return Series2;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/dataframe/index.mjs
   var DATAFRAME_SYMBOL = Symbol.for("@jrc03c/js-math-tools/dataframe");
   function makeKey3(n) {
     const alpha = "abcdefghijklmnopqrstuvwxyz1234567890";
-    let out2 = "";
-    for (let i = 0; i < n; i++)
-      out2 += alpha[Math.floor(random() * alpha.length)];
-    return out2;
+    let out = "";
+    for (let i = 0; i < n; i++) out += alpha[Math.floor(random() * alpha.length)];
+    return out;
   }
-  var DataFrame = class {
+  var DataFrame = class _DataFrame {
     static [Symbol.hasInstance](x) {
       try {
         return !!x._symbol && x._symbol === DATAFRAME_SYMBOL;
@@ -2254,20 +2585,27 @@
         set(x) {
           assert(isArray(x), "The new values must be a 2-dimensional array!");
           const dataShape = shape(x);
-          assert(dataShape.length === 2, "The new array of values must be 2-dimensional!");
+          assert(
+            dataShape.length === 2,
+            "The new array of values must be 2-dimensional!"
+          );
           if (dataShape[0] < this._index.length) {
             this._index = this._index.slice(0, dataShape[0]);
           } else if (dataShape[0] > this._index.length) {
-            this._index = this._index.concat(range(this._index.length, dataShape[0]).map((i) => {
-              return "row" + leftPad(i, (dataShape[0] - 1).toString().length);
-            }));
+            this._index = this._index.concat(
+              range(this._index.length, dataShape[0]).map((i) => {
+                return "row" + leftPad(i, (dataShape[0] - 1).toString().length);
+              })
+            );
           }
           if (dataShape[1] < this._columns.length) {
             this._columns = this._columns.slice(0, dataShape[1]);
           } else if (dataShape[1] > this._columns.length) {
-            this._columns = this._columns.concat(range(this._columns.length, dataShape[1]).map((i) => {
-              return "col" + leftPad(i, (dataShape[1] - 1).toString().length);
-            }));
+            this._columns = this._columns.concat(
+              range(this._columns.length, dataShape[1]).map((i) => {
+                return "col" + leftPad(i, (dataShape[1] - 1).toString().length);
+              })
+            );
           }
           this._values = x;
         }
@@ -2285,9 +2623,18 @@
           return this._columns;
         },
         set(x) {
-          assert(isArray(x), "The new columns list must be a 1-dimensional array of strings!");
-          assert(this.isEmpty || x.length === this.shape[1], "The new columns list must be the same length as the old columns list!");
-          assert(shape(x).length === 1, "The new columns list must be a 1-dimensional array of strings!");
+          assert(
+            isArray(x),
+            "The new columns list must be a 1-dimensional array of strings!"
+          );
+          assert(
+            this.isEmpty || x.length === this.shape[1],
+            "The new columns list must be the same length as the old columns list!"
+          );
+          assert(
+            shape(x).length === 1,
+            "The new columns list must be a 1-dimensional array of strings!"
+          );
           x = x.map((v) => {
             if (typeof v !== "string") {
               v = JSON.stringify(v) || v.toString();
@@ -2299,11 +2646,11 @@
           });
           const counts = (() => {
             const temp = count(x);
-            const out2 = {};
+            const out = {};
             temp.values.forEach((v) => {
-              out2[v] = temp.get(v);
+              out[v] = temp.get(v);
             });
-            return out2;
+            return out;
           })();
           x = x.map((v) => {
             if (counts[v] > 1) {
@@ -2327,9 +2674,18 @@
           return this._index;
         },
         set(x) {
-          assert(isArray(x), "The new index must be a 1-dimensional array of strings!");
-          assert(this.isEmpty || x.length === this.shape[0], "The new index must be the same length as the old index!");
-          assert(shape(x).length === 1, "The new index must be a 1-dimensional array of strings!");
+          assert(
+            isArray(x),
+            "The new index must be a 1-dimensional array of strings!"
+          );
+          assert(
+            this.isEmpty || x.length === this.shape[0],
+            "The new index must be the same length as the old index!"
+          );
+          assert(
+            shape(x).length === 1,
+            "The new index must be a 1-dimensional array of strings!"
+          );
           x = x.map((v) => {
             if (typeof v !== "string") {
               v = JSON.stringify(v) || v.toString();
@@ -2341,11 +2697,11 @@
           });
           const counts = (() => {
             const temp = count(x);
-            const out2 = {};
+            const out = {};
             temp.values.forEach((v) => {
-              out2[v] = temp.get(v);
+              out[v] = temp.get(v);
             });
-            return out2;
+            return out;
           })();
           x = x.map((v) => {
             if (counts[v] > 1) {
@@ -2356,16 +2712,25 @@
           this._index = x;
         }
       });
-      assert(isUndefined(data) || isObject(data) || isArray(data), "The `data` passed into the constructor of a DataFrame must be either (1) an object where the key-value pairs are (respectively) column names and 1-dimensional arrays of values, or (2) a 2-dimensional array of values.");
+      assert(
+        isUndefined(data) || isObject(data) || isArray(data),
+        "The `data` passed into the constructor of a DataFrame must be either (1) an object where the key-value pairs are (respectively) column names and 1-dimensional arrays of values, or (2) a 2-dimensional array of values."
+      );
       if (data) {
-        if (data instanceof DataFrame) {
+        if (data instanceof _DataFrame) {
           this.values = copy(data.values);
           this.columns = copy(data.columns);
           this.index = copy(data.index);
         } else if (isArray(data)) {
           const dataShape = shape(data);
-          assert(dataShape.length === 2, "The `data` array passed into the constructor of a DataFrame must be 2-dimensional!");
-          assert(!isJagged(data), "The 2-dimensional array passed into the constructor of a DataFrame must not contain sub-arrays (i.e., rows) of different lengths!");
+          assert(
+            dataShape.length === 2,
+            "The `data` array passed into the constructor of a DataFrame must be 2-dimensional!"
+          );
+          assert(
+            !isJagged(data),
+            "The 2-dimensional array passed into the constructor of a DataFrame must not contain sub-arrays (i.e., rows) of different lengths!"
+          );
           this.values = data;
         } else {
           this._columns = Object.keys(data).concat(Object.getOwnPropertySymbols(data)).map((v) => v.toString());
@@ -2377,7 +2742,10 @@
               lastColName = col;
               lastColLength = data[col].length;
             }
-            assert(data[col].length === lastColLength, `The object passed into the DataFrame constructor contains arrays of different lengths! The key "${lastColName}" points to an array containing ${lastColLength} items, and the key "${col}" points to an array containing ${data[col].length} items.`);
+            assert(
+              data[col].length === lastColLength,
+              `The object passed into the DataFrame constructor contains arrays of different lengths! The key "${lastColName}" points to an array containing ${lastColLength} items, and the key "${col}" points to an array containing ${data[col].length} items.`
+            );
             lastColLength = data[col].length;
             const values = data[col];
             temp.push(values);
@@ -2409,10 +2777,10 @@
       return this.values.length === 0 || this.values.every((row) => row.length === 0);
     }
     clear() {
-      const out2 = new DataFrame(ndarray(this.shape));
-      out2.columns = this.columns.slice();
-      out2.index = this.index.slice();
-      return out2;
+      const out = new _DataFrame(ndarray(this.shape));
+      out.columns = this.columns.slice();
+      out.index = this.index.slice();
+      return out;
     }
     get(rows, cols) {
       if (arguments.length === 0) {
@@ -2428,22 +2796,22 @@
       return dfGet(this, rows, cols);
     }
     getSubsetByNames(rows, cols) {
-      return dfGetSubsetByNames(DataFrame, Series, this, rows, cols);
+      return dfGetSubsetByNames(_DataFrame, Series, this, rows, cols);
     }
     getSubsetByIndices(rowIndices, colIndices) {
       return dfGetSubsetByIndices(this, rowIndices, colIndices);
     }
     getDummies(columns) {
-      return dfGetDummies(DataFrame, this, columns);
+      return dfGetDummies(_DataFrame, this, columns);
     }
     oneHotEncode(columns) {
-      return dfGetDummies(DataFrame, this, columns);
+      return dfGetDummies(_DataFrame, this, columns);
     }
     transpose() {
-      const out2 = new DataFrame(transpose(this.values));
-      out2.columns = this.index.slice();
-      out2.index = this.columns.slice();
-      return out2;
+      const out = new _DataFrame(transpose(this.values));
+      out.columns = this.index.slice();
+      out.index = this.columns.slice();
+      return out;
     }
     get T() {
       return this.transpose();
@@ -2452,22 +2820,22 @@
       return dfResetIndex(this, shouldSkipCopying);
     }
     copy() {
-      return dfCopy(DataFrame, this);
+      return dfCopy(_DataFrame, this);
     }
     assign(p1, p2) {
-      return dfAssign(DataFrame, Series, this, p1, p2);
+      return dfAssign(_DataFrame, Series, this, p1, p2);
     }
     apply(fn, axis) {
-      return dfApply(DataFrame, Series, this, fn, axis);
+      return dfApply(_DataFrame, Series, this, fn, axis);
     }
     dropMissing(axis, condition, threshold) {
-      return dfDropMissing(DataFrame, Series, this, axis, condition, threshold);
+      return dfDropMissing(_DataFrame, Series, this, axis, condition, threshold);
     }
     dropNaN(axis, condition, threshold) {
-      return dfDropNaN(DataFrame, this, axis, condition, threshold);
+      return dfDropNaN(_DataFrame, this, axis, condition, threshold);
     }
     drop(rows, cols) {
-      return dfDrop(DataFrame, Series, this, rows, cols);
+      return dfDrop(_DataFrame, Series, this, rows, cols);
     }
     dropColumns(columns) {
       return this.drop(null, columns);
@@ -2488,7 +2856,7 @@
       return dfToJSON(this, filename, axis);
     }
     print() {
-      return dfPrint(DataFrame, Series, this);
+      return dfPrint(_DataFrame, Series, this);
     }
     sort(cols, directions) {
       return dfSort(this, cols, directions);
@@ -2497,7 +2865,7 @@
       return this.sort();
     }
     filter(fn, axis) {
-      return dfFilter(DataFrame, Series, this, fn, axis);
+      return dfFilter(_DataFrame, Series, this, fn, axis);
     }
     shuffle(axis) {
       return dfShuffle(this, axis);
@@ -2516,12 +2884,19 @@
     }
   };
   var Series = createSeriesClass(DataFrame);
+
+  // node_modules/@jrc03c/js-math-tools/src/max.mjs
   function max(arr, shouldDropNaNs) {
     return stats(arr, { shouldDropNaNs }).max;
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/vectorize.mjs
   function vectorize(fn) {
-    assert(isFunction(fn), "You must pass a function into the `vectorize` function!");
-    return function helper5() {
+    assert(
+      isFunction(fn),
+      "You must pass a function into the `vectorize` function!"
+    );
+    return function helper4() {
       let hasSeries, hasDataFrames;
       const series = [];
       const dataframes = [];
@@ -2542,11 +2917,19 @@
         }
       }).map((key) => arguments[key]);
       childArrays.slice(0, -1).forEach((s2, i) => {
-        assert(isEqual(isArray(s2) ? shape(s2) : s2.shape, isArray(childArrays[i + 1]) ? shape(childArrays[i + 1]) : childArrays[i + 1].shape), `When passing multiple arrays into the \`${fn.name}\` function, all of the arrays must have the same shape!`);
+        assert(
+          isEqual(
+            isArray(s2) ? shape(s2) : s2.shape,
+            isArray(childArrays[i + 1]) ? shape(childArrays[i + 1]) : childArrays[i + 1].shape
+          ),
+          `When passing multiple arrays into the \`${fn.name}\` function, all of the arrays must have the same shape!`
+        );
       });
       if (childArrays.length > 0) {
-        const maxLength = max(childArrays.map((a) => a.length ? a.length : a.values.length));
-        const out2 = range(0, maxLength).map((i) => {
+        const maxLength = max(
+          childArrays.map((a) => a.length ? a.length : a.values.length)
+        );
+        const out = range(0, maxLength).map((i) => {
           const args = Object.keys(arguments).map((key) => {
             if (isArray(arguments[key])) {
               return arguments[key][i];
@@ -2558,46 +2941,47 @@
               return arguments[key];
             }
           });
-          return helper5(...args);
+          return helper4(...args);
         });
         if (hasDataFrames) {
           try {
-            if (dataframes.length === 1 && isEqual(shape(dataframes[0]), shape(out2))) {
-              const temp = new DataFrame(out2);
+            if (dataframes.length === 1 && isEqual(shape(dataframes[0]), shape(out))) {
+              const temp = new DataFrame(out);
               temp.index = dataframes[0].index.slice();
               temp.columns = dataframes[0].columns.slice();
               return temp;
             } else {
-              return new DataFrame(out2);
+              return new DataFrame(out);
             }
           } catch (e) {
-            return out2;
+            return out;
           }
         }
         if (hasSeries) {
           try {
-            if (series.length === 1 && series[0].length === out2.length) {
-              const temp = new Series(out2);
+            if (series.length === 1 && series[0].length === out.length) {
+              const temp = new Series(out);
               temp.name = series[0].name;
               temp.index = series[0].index.slice();
               return temp;
             } else {
-              return new Series(out2);
+              return new Series(out);
             }
           } catch (e) {
-            return out2;
+            return out;
           }
         }
-        return out2;
+        return out;
       } else {
         return fn(...arguments);
       }
     };
   }
+
+  // node_modules/@jrc03c/js-math-tools/src/abs.mjs
   function abs(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         return x < 0 ? -x : x;
       } else {
@@ -2608,32 +2992,35 @@
     }
   }
   var vabs = vectorize(abs);
+
+  // node_modules/@jrc03c/js-math-tools/src/add.mjs
   function add() {
     try {
-      let out2 = 0;
+      let out = 0;
       let resultShouldBeABigInt = false;
       const x = Object.values(arguments);
       for (let v of x) {
-        if (!isNumber(v))
-          return NaN;
+        if (!isNumber(v)) return NaN;
         if (typeof v === "bigint") {
           resultShouldBeABigInt = true;
           v = Number(v);
         }
-        out2 += v;
+        out += v;
       }
       if (resultShouldBeABigInt) {
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
         }
       }
-      return out2;
+      return out;
     } catch (e) {
       return NaN;
     }
   }
   var vadd = vectorize(add);
+
+  // node_modules/@jrc03c/js-math-tools/src/apply.mjs
   function apply(x, fn) {
     try {
       return fn(x);
@@ -2642,10 +3029,11 @@
     }
   }
   var vapply = vectorize(apply);
+
+  // node_modules/@jrc03c/js-math-tools/src/arccos.mjs
   function arccos(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         x = Number(x);
       }
@@ -2655,10 +3043,11 @@
     }
   }
   var varccos = vectorize(arccos);
+
+  // node_modules/@jrc03c/js-math-tools/src/arcsin.mjs
   function arcsin(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         x = Number(x);
       }
@@ -2668,10 +3057,11 @@
     }
   }
   var varcsin = vectorize(arcsin);
+
+  // node_modules/@jrc03c/js-math-tools/src/arctan.mjs
   function arctan(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         x = Number(x);
       }
@@ -2681,226 +3071,24 @@
     }
   }
   var varctan = vectorize(arctan);
-  function argmax(x, shouldDropNaNs) {
-    if (isDataFrame(x)) {
-      const index = argmax(x.values, shouldDropNaNs);
-      return [x.index[index[0]], x.columns[index[1]]];
-    }
-    if (isSeries(x)) {
-      const index = argmax(x.values, shouldDropNaNs);
-      return x.index[index];
-    }
-    assert(isArray(x), "The `argmax` function only works on arrays, Series, and DataFrames!");
-    try {
-      const out2 = indexOf(x, max(x, shouldDropNaNs));
-      if (out2) {
-        if (out2.length === 0) {
-          return void 0;
-        } else if (out2.length === 1) {
-          return out2[0];
-        } else {
-          return out2;
-        }
-      } else {
-        return void 0;
-      }
-    } catch (e) {
-      return void 0;
-    }
-  }
-  function min(arr, shouldDropNaNs) {
-    return stats(arr, { shouldDropNaNs }).min;
-  }
-  function argmin(x, shouldDropNaNs) {
-    if (isDataFrame(x)) {
-      const index = argmin(x.values, shouldDropNaNs);
-      return [x.index[index[0]], x.columns[index[1]]];
-    }
-    if (isSeries(x)) {
-      const index = argmin(x.values, shouldDropNaNs);
-      return x.index[index];
-    }
-    assert(isArray(x), "The `argmin` function only works on arrays, Series, and DataFrames!");
-    try {
-      const out2 = indexOf(x, min(x, shouldDropNaNs));
-      if (out2) {
-        if (out2.length === 0) {
-          return void 0;
-        } else if (out2.length === 1) {
-          return out2[0];
-        } else {
-          return out2;
-        }
-      } else {
-        return void 0;
-      }
-    } catch (e) {
-      return void 0;
-    }
-  }
-  function cast(value, type) {
-    if (isDataFrame(value) || isSeries(value)) {
-      return value.apply((item) => cast(item, type));
-    }
-    if (isArray(value)) {
-      return value.map((v) => cast(v, type));
-    }
-    if (type === "null") {
-      return null;
-    }
-    if (type === "number") {
-      if (isUndefined(value)) {
-        return NaN;
-      }
-      const booleanValue = cast(value, "boolean");
-      if (isBoolean(booleanValue)) {
-        return booleanValue ? 1 : 0;
-      }
-      try {
-        JSON.parse(value);
-      } catch (e) {
-        const dateValue = cast(value, "date");
-        if (isDate(dateValue)) {
-          return dateValue.getTime();
-        }
-      }
-      const out2 = parseFloat(value);
-      if (isNaN(out2))
-        return NaN;
-      return out2;
-    }
-    if (type === "int") {
-      const out2 = cast(value, "number");
-      return out2 >= 0 ? Math.floor(out2) : Math.ceil(out2);
-    }
-    if (type === "float") {
-      return cast(value, "number");
-    }
-    if (type === "bigint") {
-      if (typeof value === "bigint") {
-        return value;
-      }
-      return BigInt(cast(value, "int"));
-    }
-    if (type === "boolean") {
-      if (isBoolean(value)) {
-        return value;
-      }
-      if (isNumber(value)) {
-        if (value === 0) {
-          return false;
-        }
-        if (value === 1) {
-          return true;
-        }
-        return null;
-      }
-      try {
-        const vBool = (typeof value === "object" ? value.toString() === "null" ? "false" : JSON.stringify(value) : value.toString()).trim().toLowerCase();
-        if (vBool === "true" || vBool === "yes" || vBool === "y") {
-          return true;
-        }
-        if (vBool === "false" || vBool === "no" || vBool === "n") {
-          return false;
-        }
-        return null;
-      } catch (e) {
-        return null;
-      }
-    }
-    if (type === "date") {
-      if (isDate(value)) {
-        return value;
-      }
-      if (isUndefined(value)) {
-        return null;
-      }
-      const valueFloat = parseFloat(value);
-      if (!isNaN(valueFloat)) {
-        const out2 = new Date(value);
-        if (!isDate(out2))
-          return null;
-        return out2;
-      }
-      const valueDate = Date.parse(value);
-      if (!isNaN(valueDate)) {
-        return new Date(valueDate);
-      }
-      return null;
-    }
-    if (type === "object") {
-      if (isObject(value)) {
-        return value;
-      }
-      const booleanValue = cast(value, "boolean");
-      if (isBoolean(booleanValue)) {
-        return null;
-      }
-      try {
-        const numberValue = cast(value, "number");
-        if (isNumber(numberValue)) {
-          JSON.parse(value);
-          return null;
-        }
-      } catch (e) {
-      }
-      const dateValue = cast(value, "date");
-      if (dateValue) {
-        return dateValue;
-      }
-      try {
-        const out2 = JSON.parse(value);
-        if (isArray(out2)) {
-          return out2.map((v) => cast(v, type));
-        } else {
-          return out2;
-        }
-      } catch (e) {
-        return null;
-      }
-    }
-    if (type === "string") {
-      if (isUndefined(value)) {
-        if (isEqual(value, void 0)) {
-          return "undefined";
-        }
-        return "null";
-      }
-      if (value instanceof Date) {
-        return value.toJSON();
-      }
-      const valueString = (() => {
-        if (typeof value === "object") {
-          if (value === null) {
-            return "null";
-          } else {
-            return JSON.stringify(value);
-          }
-        } else {
-          return value.toString();
-        }
-      })();
-      return valueString;
-    }
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/ceil.mjs
   function ceil(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
-      if (typeof x === "bigint")
-        return x;
+      if (!isNumber(x)) return NaN;
+      if (typeof x === "bigint") return x;
       return Math.ceil(x);
     } catch (e) {
       return NaN;
     }
   }
   var vceil = vectorize(ceil);
+
+  // node_modules/@jrc03c/js-math-tools/src/chop.mjs
   function chop(x, threshold) {
     try {
-      if (!isNumber(x))
-        return NaN;
-      if (typeof x === "bigint")
-        return x;
+      if (!isNumber(x)) return NaN;
+      if (typeof x === "bigint") return x;
       if (isUndefined(threshold)) {
         threshold = 1e-10;
       } else if (!isNumber(threshold)) {
@@ -2912,19 +3100,21 @@
     }
   }
   var vchop = vectorize(chop);
+
+  // node_modules/@jrc03c/js-math-tools/src/int.mjs
   function int(x) {
     if (isDataFrame(x) || isSeries(x)) {
-      const out2 = x.copy();
-      out2.values = int(out2.values);
-      return out2;
+      const out = x.copy();
+      out.values = int(out.values);
+      return out;
     }
     if (isArray(x)) {
       return x.map((v) => int(v));
     } else {
       try {
-        const out2 = JSON.parse(x);
-        if (isNumber(out2)) {
-          return typeof out2 === "bigint" ? Number(out2) : out2 >= 0 ? Math.floor(out2) : Math.ceil(out2);
+        const out = JSON.parse(x);
+        if (isNumber(out)) {
+          return typeof out === "bigint" ? Number(out) : out >= 0 ? Math.floor(out) : Math.ceil(out);
         }
         return NaN;
       } catch (e) {
@@ -2933,199 +3123,29 @@
     }
   }
   var vint = vectorize(int);
+
+  // node_modules/@jrc03c/js-math-tools/src/clamp.mjs
   function clamp(x, a, b) {
     try {
-      if (!isNumber(x))
-        return NaN;
-      if (!isNumber(a))
-        return NaN;
-      if (!isNumber(b))
-        return NaN;
+      if (!isNumber(x)) return NaN;
+      if (!isNumber(a)) return NaN;
+      if (!isNumber(b)) return NaN;
       if (typeof x === "bigint") {
         return BigInt(clamp(vint(x), a, b));
       }
-      if (x < a)
-        return a;
-      if (x > b)
-        return b;
+      if (x < a) return a;
+      if (x > b) return b;
       return x;
     } catch (e) {
       return NaN;
     }
   }
   var vclamp = vectorize(clamp);
-  function combinationsIterator(x, r) {
-    function* helper5(x2, r2) {
-      if (r2 > x2.length) {
-        yield x2;
-      } else if (r2 <= 0) {
-        yield [];
-      } else if (x2.length < 2) {
-        yield x2;
-      } else {
-        for (let i = 0; i < x2.length; i++) {
-          const item = x2[i];
-          const after = x2.slice(i + 1);
-          if (after.length < r2 - 1) {
-            continue;
-          }
-          if (r2 - 1 >= 0) {
-            for (const child of combinationsIterator(after, r2 - 1)) {
-              yield [item].concat(child);
-            }
-          }
-        }
-      }
-    }
-    if (isDataFrame(x) || isSeries(x)) {
-      return combinationsIterator(x.values, r);
-    }
-    assert(isArray(x), "The `combinations` function only works on arrays, Series, and DataFrames!");
-    assert(isNumber(r) && vint(r) === r && r >= 0, "`r` must be a non-negative integer!");
-    return helper5(flatten(x), r);
-  }
-  function combinations(x, r) {
-    const out2 = [];
-    for (const combo of combinationsIterator(x, r)) {
-      out2.push(combo.slice());
-    }
-    return out2;
-  }
-  function intersect() {
-    const arrays = Object.values(arguments).map((x) => {
-      if (isDataFrame(x) || isSeries(x)) {
-        return set(x.values);
-      }
-      assert(isArray(x), "The `intersect` function only works on arrays, Series, and DataFrames!");
-      return set(x);
-    });
-    const all = set(arrays);
-    return all.filter((v) => {
-      return arrays.every((arr) => arr.findIndex((other) => isEqual(other, v)) > -1);
-    });
-  }
-  var _IndexMatcher = class {
-    constructor(mode2) {
-      assert(isUndefined(mode2) || mode2 === _IndexMatcher.DROP_NAN_MODE || mode2 === _IndexMatcher.DROP_MISSING_MODE, "The `mode` value passed into the `IndexMatcher` constructor must be undefined or one of [IndexMatcher.DROP_NAN_MODE, IndexMatcher.DROP_MISSING_MODE]! (By default, the mode is `Indexer.DROP_MISSING_MODE`.)");
-      this.mode = !isUndefined(mode2) ? mode2 : _IndexMatcher.DROP_NAN_MODE;
-      this.index = null;
-    }
-    fit() {
-      const indices = [];
-      Object.values(arguments).forEach((x) => {
-        if (isArray(x)) {
-          const xshape = shape(x);
-          if (xshape.length === 1) {
-            x = new Series(x);
-          } else if (xshape.length === 2) {
-            x = new DataFrame(x);
-          } else {
-            throw new Error("The `IndexMatcher.fit` method only works on arrays, Series, and DataFrames!");
-          }
-        }
-        assert(isDataFrame(x) || isSeries(x), "The `IndexMatcher.fit` method only works on arrays, Series, and DataFrames!");
-        if (this.mode === _IndexMatcher.DROP_MISSING_MODE) {
-          indices.push(x.dropMissing().index);
-        } else {
-          indices.push(x.dropNaN().index);
-        }
-      });
-      this.index = intersect(...indices);
-      return this;
-    }
-    transform() {
-      assert(!!this.index, "The IndexMatcher hasn't been fitted yet! Please call the `fit` method before calling the `transform` method.");
-      const out2 = Object.values(arguments).map((x) => {
-        if (isArray(x)) {
-          const xshape = shape(x);
-          if (xshape.length === 1) {
-            return new Series(x).get(this.index).values;
-          } else if (xshape.length === 2) {
-            return new DataFrame(x).get(this.index, null).values;
-          } else {
-            throw new Error("The `IndexMatcher.fit` method only works on arrays, Series, and DataFrames!");
-          }
-        }
-        assert(isDataFrame(x) || isSeries(x), "The `IndexMatcher.fit` method only works on arrays, Series, and DataFrames!");
-        return x.get(this.index, null);
-      });
-      return out2.length === 1 ? out2[0] : out2;
-    }
-    fitAndTransform() {
-      return this.fit(...arguments).transform(...arguments);
-    }
-  };
-  var IndexMatcher = _IndexMatcher;
-  __publicField(IndexMatcher, "DROP_NAN_MODE", "DROP_NAN_MODE");
-  __publicField(IndexMatcher, "DROP_MISSING_MODE", "DROP_MISSING_MODE");
-  function covariance(x, y, shouldDropNaNs, shouldAlsoReturnStatsObjects) {
-    if (isSeries(x)) {
-      return covariance(x.values, y, shouldDropNaNs, shouldAlsoReturnStatsObjects);
-    }
-    if (isSeries(y)) {
-      return covariance(x, y.values, shouldDropNaNs, shouldAlsoReturnStatsObjects);
-    }
-    assert(isArray(x) && isArray(y) && shape(x).length === 1 && shape(y).length === 1, "The `covariance` function only works on 1-dimensional arrays and Series!");
-    assert(x.length === y.length, "The two arrays or Series passed into the `covariance` function must have the same length!");
-    if (shouldDropNaNs) {
-      return covariance(...new IndexMatcher().fitAndTransform(x, y), false, shouldAlsoReturnStatsObjects);
-    }
-    try {
-      const xstats = stats(x, { stdev: shouldAlsoReturnStatsObjects });
-      const ystats = stats(y, { stdev: shouldAlsoReturnStatsObjects });
-      const mx = Number(xstats.mean);
-      const my = Number(ystats.mean);
-      if (!isNumber(mx) || !isNumber(my)) {
-        return NaN;
-      }
-      const n = Math.max(x.length, y.length);
-      let out2 = 0;
-      for (let i = 0; i < n; i++) {
-        let vx = x[i];
-        let vy = y[i];
-        if (!isNumber(vx))
-          return NaN;
-        if (!isNumber(vy))
-          return NaN;
-        if (typeof vx === "bigint") {
-          vx = Number(vx);
-        }
-        if (typeof vy === "bigint") {
-          vy = Number(vy);
-        }
-        out2 += (vx - mx) * (vy - my);
-      }
-      if (shouldAlsoReturnStatsObjects) {
-        return [out2 / x.length, xstats, ystats];
-      } else {
-        return out2 / x.length;
-      }
-    } catch (e) {
-      return NaN;
-    }
-  }
-  function correl(x, y, shouldDropNaNs) {
-    if (isSeries(x)) {
-      return correl(x.values, y, shouldDropNaNs);
-    }
-    if (isSeries(y)) {
-      return correl(x, y.values, shouldDropNaNs);
-    }
-    assert(isArray(x) && isArray(y) && shape(x).length === 1 && shape(y).length === 1, "The `correl` function only works on 1-dimensional arrays and Series!");
-    assert(x.length === y.length, "The two arrays or Series passed into the `correl` function must have the same length!");
-    try {
-      const shouldAlsoReturnStatsObjects = true;
-      const [num, xstats, ystats] = covariance(x, y, shouldDropNaNs, shouldAlsoReturnStatsObjects);
-      const den = xstats.stdev * ystats.stdev;
-      return num / den;
-    } catch (e) {
-      return NaN;
-    }
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/cos.mjs
   function cos(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         x = Number(x);
       }
@@ -3135,6 +3155,8 @@
     }
   }
   var vcos = vectorize(cos);
+
+  // node_modules/@jrc03c/js-math-tools/src/helpers/data-types.mjs
   var dataTypes = Object.freeze({
     boolean: "boolean",
     date: "date",
@@ -3143,36 +3165,18 @@
     object: "object",
     string: "string"
   });
-  function diff(a, b) {
-    if (isDataFrame(a) || isSeries(a)) {
-      return diff(a.values, b);
-    }
-    if (isDataFrame(b) || isSeries(b)) {
-      return diff(a, b.values);
-    }
-    assert(isArray(a) && isArray(b), "The `diff` function only works on arrays, Series, and DataFrames!");
-    const aTemp = set(a);
-    const bTemp = set(b);
-    const out2 = [];
-    aTemp.forEach((item) => {
-      if (bTemp.findIndex((other) => isEqual(other, item)) < 0) {
-        out2.push(item);
-      }
-    });
-    return out2;
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/pow.mjs
   function pow(x, p) {
     try {
-      if (!isNumber(x))
-        return NaN;
-      if (!isNumber(p))
-        return NaN;
+      if (!isNumber(x)) return NaN;
+      if (!isNumber(p)) return NaN;
       if (typeof x === "bigint" || typeof p === "bigint") {
-        const out2 = pow(Number(x), Number(p));
+        const out = pow(Number(x), Number(p));
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
-          return out2;
+          return out;
         }
       }
       return Math.pow(x, p);
@@ -3181,16 +3185,17 @@
     }
   }
   var vpow = vectorize(pow);
+
+  // node_modules/@jrc03c/js-math-tools/src/sqrt.mjs
   function sqrt(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
-        const out2 = sqrt(Number(x));
+        const out = sqrt(Number(x));
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
-          return out2;
+          return out;
         }
       }
       return Math.sqrt(x);
@@ -3199,218 +3204,39 @@
     }
   }
   var vsqrt = vectorize(sqrt);
+
+  // node_modules/@jrc03c/js-math-tools/src/multiply.mjs
   function multiply() {
     try {
       const x = Object.values(arguments);
-      if (x.length === 0)
-        return NaN;
+      if (x.length === 0) return NaN;
       let resultShouldBeABigInt = false;
-      let out2 = 1;
+      let out = 1;
       for (let v of x) {
-        if (!isNumber(v))
-          return NaN;
+        if (!isNumber(v)) return NaN;
         if (typeof v === "bigint") {
           resultShouldBeABigInt = true;
           v = Number(v);
         }
-        out2 *= v;
+        out *= v;
       }
       if (resultShouldBeABigInt) {
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
         }
       }
-      return out2;
+      return out;
     } catch (e) {
       return NaN;
     }
   }
   var vmultiply = vectorize(multiply);
-  function scale() {
-    return vmultiply(...arguments);
-  }
-  function subtract(a, b) {
-    return vadd(a, scale(b, -1));
-  }
-  function sum(arr, shouldDropNaNs) {
-    return stats(arr, { shouldDropNaNs }).sum;
-  }
-  function distance(a, b) {
-    if (isNumber(a) && isNumber(b)) {
-      return vabs(a - b);
-    }
-    if (isDataFrame(a) || isSeries(a)) {
-      return distance(a.values, b);
-    }
-    if (isDataFrame(b) || isSeries(b)) {
-      return distance(a, b.values);
-    }
-    if (isArray(a) && isArray(b)) {
-      assert(isEqual(shape(a), shape(b)), "If passing two arrays, Series, or DataFrames into the `distance` function, then those objects must have the same shape!");
-    }
-    try {
-      return vsqrt(sum(vpow(subtract(a, b), 2)));
-    } catch (e) {
-      return NaN;
-    }
-  }
-  function divide(a, b) {
-    return scale(a, vpow(b, -1));
-  }
-  function dot(a, b) {
-    if (isDataFrame(a)) {
-      const temp = dot(a.values, b);
-      if (shape(temp).length === 1) {
-        const out2 = new Series(temp);
-        out2.name = isSeries(b) ? b.name : out2.name;
-        out2.index = a.index.slice();
-        return out2;
-      } else {
-        const out2 = new DataFrame(temp);
-        out2.index = a.index.slice();
-        if (isDataFrame(b)) {
-          out2.columns = b.columns.slice();
-        }
-        return out2;
-      }
-    }
-    if (isDataFrame(b)) {
-      const temp = dot(a, b.values);
-      if (shape(temp).length === 1) {
-        const out2 = new Series(temp);
-        out2.name = isSeries(a) ? a.name : out2.name;
-        out2.index = b.columns.slice();
-        return out2;
-      } else {
-        const out2 = new DataFrame(temp);
-        out2.columns = b.columns.slice();
-        return out2;
-      }
-    }
-    if (isSeries(a)) {
-      return dot(a.values, b);
-    }
-    if (isSeries(b)) {
-      return dot(a, b.values);
-    }
-    assert(isArray(a) && isArray(b), "The `dot` function only works on arrays, Series, and DataFrames!");
-    const aShape = shape(a);
-    const bShape = shape(b);
-    assert(aShape.length <= 2 && bShape.length <= 2, "I'm not smart enough to know how to get the dot-product of arrays that have more than 2 dimensions. Sorry for the inconvenience! Please only pass 1- or 2-dimensional arrays into the `dot` function!");
-    assert(aShape[aShape.length - 1] === bShape[0], `There's a dimension misalignment in the two arrays you passed into the \`dot\` function. (${aShape[aShape.length - 1]} !== ${bShape[0]})`);
-    if (aShape.length === 1 && bShape.length === 1) {
-      return sum(scale(a, b));
-    } else if (aShape.length === 1 && bShape.length === 2) {
-      return transpose(b).map((col) => dot(a, col));
-    } else if (aShape.length === 2 && bShape.length === 1) {
-      return a.map((row) => dot(row, b));
-    } else if (aShape.length === 2 && bShape.length === 2) {
-      const bTranspose = transpose(b);
-      const out2 = [];
-      for (let i = 0; i < a.length; i++) {
-        const row = [];
-        for (let j = 0; j < bTranspose.length; j++) {
-          row.push(dot(a[i], bTranspose[j]));
-        }
-        out2.push(row);
-      }
-      return out2;
-    }
-  }
-  function dropMissing(x) {
-    if (isDataFrame(x) || isSeries(x)) {
-      return x.dropMissing(...Object.values(arguments).slice(1));
-    }
-    assert(isArray(x), "The `dropMissing` function only works on arrays, Series, and DataFrames!");
-    const out2 = [];
-    x.forEach((v) => {
-      try {
-        return out2.push(dropMissing(v));
-      } catch (e) {
-        if (!isUndefined(v)) {
-          out2.push(v);
-        }
-      }
-    });
-    return out2;
-  }
-  function dropMissingPairwise(a, b) {
-    if (isDataFrame(a) || isSeries(a)) {
-      return dropMissingPairwise(a.values, b);
-    }
-    if (isDataFrame(b) || isSeries(b)) {
-      return dropMissingPairwise(a, b.values);
-    }
-    assert(isArray(a) && isArray(b), "The `dropMissingPairwise` function only works on arrays, Series, and DataFrames!");
-    assert(isEqual(shape(a), shape(b)), "The two arrays, Series, and/or DataFrames passed into the `dropMissingPairwise` function must have the same shape!");
-    const aOut = [];
-    const bOut = [];
-    for (let i = 0; i < a.length; i++) {
-      try {
-        const [aChildren, bChildren] = dropMissingPairwise(a[i], b[i]);
-        aOut.push(aChildren);
-        bOut.push(bChildren);
-      } catch (e) {
-        if (!isUndefined(a[i]) && !isUndefined(b[i])) {
-          aOut.push(a[i]);
-          bOut.push(b[i]);
-        }
-      }
-    }
-    return [aOut, bOut];
-  }
-  function dropNaNPairwise(a, b) {
-    if (isDataFrame(a) || isSeries(a)) {
-      return dropNaNPairwise(a.values, b);
-    }
-    if (isDataFrame(b) || isSeries(b)) {
-      return dropNaNPairwise(a, b.values);
-    }
-    assert(isArray(a) && isArray(b), "The `dropNaNPairwise` only works on arrays, Series, and DataFrames!");
-    assert(isEqual(shape(a), shape(b)), "The two arrays, Series, and/or DataFrames passed into the `dropNaNPairwise` must have the same shape!");
-    const aOut = [];
-    const bOut = [];
-    for (let i = 0; i < a.length; i++) {
-      try {
-        const [aChildren, bChildren] = dropNaNPairwise(a[i], b[i]);
-        aOut.push(aChildren);
-        bOut.push(bChildren);
-      } catch (e) {
-        if (isNumber(a[i]) && isNumber(b[i])) {
-          aOut.push(a[i]);
-          bOut.push(b[i]);
-        }
-      }
-    }
-    return [aOut, bOut];
-  }
-  function dropUndefined(x) {
-    return dropMissing(x);
-  }
-  function every(x, fn) {
-    if (isDataFrame(x) || isSeries(x)) {
-      return every(x.values, fn);
-    }
-    assert(isArray(x), "The first argument passed into the `every` function must be an array, Series, or DataFrame!");
-    assert(isFunction(fn), "The second argument passed into the `every` function must be a function!");
-    for (const v of x) {
-      if (isArray(v)) {
-        if (!every(v, fn)) {
-          return false;
-        }
-      } else {
-        if (!fn(v)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/exp.mjs
   function exp(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         if (x === 0n) {
           return 1n;
@@ -3424,152 +3250,23 @@
     }
   }
   var vexp = vectorize(exp);
+
+  // node_modules/@jrc03c/js-math-tools/src/factorial.mjs
   function factorial(n) {
     try {
       if (typeof n === "bigint") {
         return BigInt(factorial(vint(n)));
       }
-      if (n !== vint(n))
-        return NaN;
-      if (n <= 1)
-        return 1;
+      if (n !== vint(n)) return NaN;
+      if (n <= 1) return 1;
       return n * factorial(n - 1);
     } catch (e) {
       return NaN;
     }
   }
   var vfactorial = vectorize(factorial);
-  function find(x, fn) {
-    if (isDataFrame(x)) {
-      return find(x.values, fn);
-    }
-    if (isSeries(x)) {
-      return find(x.values, fn);
-    }
-    assert(isObject(x) || isArray(x), "You must pass (1) an object, array, Series, or DataFrame and (2) a function or value into the `find` function!");
-    if (!isFunction(fn)) {
-      const value = fn;
-      fn = (v) => v === value;
-    }
-    function helper5(x2, fn2, checked) {
-      checked = checked || [];
-      if (checked.indexOf(x2) > -1) {
-        return null;
-      }
-      if (isObject(x2)) {
-        checked.push(x2);
-        const keys = Object.keys(x2).concat(Object.getOwnPropertySymbols(x2));
-        for (let i = 0; i < keys.length; i++) {
-          const key = keys[i];
-          const value = x2[key];
-          if (fn2(value)) {
-            return value;
-          }
-          const result = helper5(value, fn2, checked);
-          if (result) {
-            return result;
-          }
-        }
-      } else if (isArray(x2)) {
-        checked.push(x2);
-        for (let i = 0; i < x2.length; i++) {
-          const value = x2[i];
-          if (fn2(value)) {
-            return value;
-          }
-          const result = helper5(value, fn2, checked);
-          if (result) {
-            return result;
-          }
-        }
-      } else {
-        if (fn2(x2)) {
-          return x2;
-        }
-      }
-      return null;
-    }
-    function safeFn(v) {
-      try {
-        return fn(v);
-      } catch (e) {
-        return false;
-      }
-    }
-    return helper5(x, safeFn);
-  }
-  function findAll(x, fn) {
-    if (isDataFrame(x)) {
-      return findAll(x.values, fn);
-    }
-    if (isSeries(x)) {
-      return findAll(x.values, fn);
-    }
-    assert(isObject(x) || isArray(x), "You must pass (1) an object, array, Series, or DataFrame and (2) a function or value into the `findAll` function!");
-    if (!isFunction(fn)) {
-      const value = fn;
-      fn = (v) => v === value;
-    }
-    function helper5(x2, fn2, checked) {
-      checked = checked || [];
-      if (checked.indexOf(x2) > -1) {
-        return null;
-      }
-      if (isObject(x2)) {
-        checked.push(x2);
-        const keys = Object.keys(x2).concat(Object.getOwnPropertySymbols(x2));
-        const out2 = [];
-        for (let i = 0; i < keys.length; i++) {
-          const key = keys[i];
-          const value = x2[key];
-          let alreadyStoredThisValue = false;
-          if (fn2(value)) {
-            out2.push(value);
-            alreadyStoredThisValue = true;
-          }
-          const results2 = helper5(value, fn2, checked);
-          if (results2 && results2.length > 0) {
-            results2.slice(alreadyStoredThisValue ? 1 : 0).forEach((r) => out2.push(r));
-          }
-        }
-        return out2;
-      } else if (isArray(x2)) {
-        checked.push(x2);
-        const out2 = [];
-        for (let i = 0; i < x2.length; i++) {
-          const value = x2[i];
-          let alreadyStoredThisValue = false;
-          if (fn2(value)) {
-            out2.push(value);
-            alreadyStoredThisValue = true;
-          }
-          const results2 = helper5(value, fn2, checked);
-          if (results2 && results2.length > 0) {
-            results2.slice(alreadyStoredThisValue ? 1 : 0).forEach((r) => out2.push(r));
-          }
-        }
-        return out2;
-      } else {
-        if (fn2(x2)) {
-          return [x2];
-        }
-      }
-      return null;
-    }
-    function safeFn(v) {
-      try {
-        return fn(v);
-      } catch (e) {
-        return false;
-      }
-    }
-    const results = helper5(x, safeFn);
-    if (results && results.length > 0) {
-      return results;
-    } else {
-      return null;
-    }
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/float.mjs
   function float(x) {
     try {
       if (x === "Infinity") {
@@ -3578,19 +3275,19 @@
       if (x === "-Infinity") {
         return -Infinity;
       }
-      const out2 = JSON.parse(x);
-      if (isNumber(out2))
-        return out2;
+      const out = JSON.parse(x);
+      if (isNumber(out)) return out;
       return NaN;
     } catch (e) {
       return NaN;
     }
   }
   var vfloat = vectorize(float);
+
+  // node_modules/@jrc03c/js-math-tools/src/floor.mjs
   function floor(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         return x;
       }
@@ -3600,203 +3297,19 @@
     }
   }
   var vfloor = vectorize(floor);
-  function zeros(shape2) {
-    if (isNumber(shape2))
-      shape2 = [shape2];
-    const out2 = [];
-    const n = product(shape2);
-    for (let i = 0; i < n; i++)
-      out2.push(0);
-    return reshape(out2, shape2);
-  }
-  function identity(size) {
-    if (typeof size === "bigint") {
-      size = vint(size);
-    }
-    assert(!isUndefined(size), "You must pass an integer greater than 0 (representing the size) into the `identity` function!");
-    assert(isNumber(size), "You must pass an integer greater than 0 (representing the size) into the `identity` function!");
-    assert(vint(size) === size, "You must pass an integer greater than 0 (representing the size) into the `identity` function!");
-    assert(size > 0, "You must pass an integer greater than 0 (representing the size) into the `identity` function!");
-    const out2 = zeros([size, size]);
-    for (let i = 0; i < size; i++)
-      out2[i][i] = 1;
-    return out2;
-  }
-  var booleanValues = ["true", "false", "yes", "no"];
-  var nullValues = ["null", "none", "nan", "na", "n/a", "", "undefined"];
-  function checkIfInteger(results) {
-    if (results.type === "number") {
-      if (typeof results.value !== "undefined") {
-        results.isInteger = vint(results.value) === results.value;
-      } else {
-        results.isInteger = every(results.values, (v) => isNumber(v) ? vint(v) === v : true);
-      }
-    }
-    return results;
-  }
-  function inferType(arr) {
-    if (isDataFrame(arr)) {
-      const out2 = arr.copy();
-      const results = inferType(arr.values);
-      out2.values = results.values;
-      return checkIfInteger({ type: results.type, values: out2 });
-    }
-    if (isSeries(arr)) {
-      const out2 = arr.copy();
-      const results = inferType(arr.values);
-      out2.values = results.values;
-      return checkIfInteger({ type: results.type, values: out2 });
-    }
-    if (!isArray(arr)) {
-      const out2 = inferType([arr]);
-      out2.value = out2.values[0];
-      delete out2.values;
-      return checkIfInteger(out2);
-    }
-    assert(isArray(arr), "The `inferType` function only works on arrays, Series, and DataFrames!");
-    const types = flatten(arr).map((v) => {
-      if (v === void 0)
-        return "null";
-      try {
-        if (typeof v === "object") {
-          const temp = new Date(v.getTime());
-          if (isDate(temp)) {
-            return "date";
-          }
-        }
-      } catch (e) {
-      }
-      if (!isString(v)) {
-        if (typeof v === "bigint") {
-          v = v.toString() + "n";
-        } else {
-          v = JSON.stringify(v);
-        }
-      }
-      const vLower = v.toLowerCase();
-      const vLowerTrimmed = vLower.trim();
-      if (nullValues.indexOf(vLowerTrimmed) > -1) {
-        return "null";
-      }
-      if (booleanValues.indexOf(vLowerTrimmed) > -1) {
-        return "boolean";
-      }
-      try {
-        if (v.match(/^-?\d+n$/g)) {
-          return "bigint";
-        }
-        const vParsed = JSON.parse(v);
-        if (isNumber(vParsed)) {
-          return "number";
-        }
-        if (typeof vParsed === "object") {
-          if (isArray(vParsed))
-            return "string";
-          return "object";
-        }
-        return "string";
-      } catch (e) {
-        const vDate = new Date(v);
-        if (isDate(vDate)) {
-          return "date";
-        }
-        return "string";
-      }
-    });
-    const counts = count(types);
-    const sortedValues = counts.values.toSorted((a, b) => counts.get(b) - counts.get(a));
-    const primaryType = sortedValues[0];
-    return checkIfInteger({
-      type: primaryType,
-      values: vapply(arr, (v) => cast(v, primaryType))
-    });
-  }
-  function inverse(x) {
-    if (isDataFrame(x)) {
-      const out2 = x.copy();
-      out2.values = inverse(out2.values);
-      return out2;
-    }
-    assert(isArray(x), "The `inverse` function only works on square 2-dimensional arrays or DataFrames!");
-    const xShape = shape(x);
-    assert(xShape.length === 2, "The array passed into the `inverse` function must be exactly two-dimensional and square!");
-    assert(xShape[0] === xShape[1], "The array passed into the `inverse` function must be exactly two-dimensional and square!");
-    assert(xShape[0] >= 0, "The array passed into the `inverse` function must be exactly two-dimensional and square!");
-    if (xShape[0] === 0) {
-      return x;
-    } else if (xShape[0] === 1) {
-      assert(x[0][0] !== 0, "This matrix cannot be inverted!");
-      let v = x[0][0];
-      if (typeof v === "bigint")
-        v = Number(v);
-      return 1 / v;
-    } else if (xShape[0] === 2) {
-      let a = x[0][0];
-      let b = x[0][1];
-      let c = x[1][0];
-      let d = x[1][1];
-      if (typeof a === "bigint")
-        a = Number(a);
-      if (typeof b === "bigint")
-        b = Number(b);
-      if (typeof c === "bigint")
-        c = Number(c);
-      if (typeof d === "bigint")
-        d = Number(d);
-      const det = a * d - b * c;
-      assert(det !== 0, "This matrix cannot be inverted!");
-      const out2 = [
-        [d, -b],
-        [-c, a]
-      ];
-      return scale(out2, 1 / det);
-    } else if (xShape[0] > 1) {
-      const times = (a, b) => isNumber(a) || isNumber(b) ? scale(a, b) : dot(a, b);
-      for (let divider = 1; divider < xShape[0] - 1; divider++) {
-        try {
-          const A = x.slice(0, divider).map((row) => row.slice(0, divider));
-          const B = x.slice(0, divider).map((row) => row.slice(divider, xShape[0]));
-          const C = x.slice(divider, xShape[0]).map((row) => row.slice(0, divider));
-          const D = x.slice(divider, xShape[0]).map((row) => row.slice(divider, xShape[0]));
-          const AInv = inverse(A);
-          const CompInv = inverse(vadd(D, times(-1, times(times(C, AInv), B))));
-          const topLeft = vadd(AInv, times(times(times(times(AInv, B), CompInv), C), AInv));
-          const topRight = times(-1, times(times(AInv, B), CompInv));
-          const bottomLeft = times(-1, times(times(CompInv, C), AInv));
-          const bottomRight = CompInv;
-          const out2 = topLeft.map((row, i) => row.concat(topRight[i])).concat(bottomLeft.map((row, i) => row.concat(bottomRight[i])));
-          return out2;
-        } catch (e) {
-        }
-      }
-      assert(false, "This matrix cannot be inverted!");
-    }
-  }
-  var isBrowser2 = new Function(`
-    try {
-      return this === window
-    } catch(e) {}
-
-    try {
-      return !!importScripts
-    } catch(e){}
 
-    return false
-  `);
+  // node_modules/@jrc03c/js-math-tools/src/lerp.mjs
   function lerp(a, b, f) {
     try {
-      if (!isNumber(a))
-        return NaN;
-      if (!isNumber(b))
-        return NaN;
-      if (!isNumber(f))
-        return NaN;
+      if (!isNumber(a)) return NaN;
+      if (!isNumber(b)) return NaN;
+      if (!isNumber(f)) return NaN;
       if (typeof a === "bigint" || typeof b === "bigint") {
-        const out2 = lerp(Number(a), Number(b), f);
+        const out = lerp(Number(a), Number(b), f);
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
-          return out2;
+          return out;
         }
       }
       return f * (b - a) + a;
@@ -3805,19 +3318,19 @@
     }
   }
   var vlerp = vectorize(lerp);
+
+  // node_modules/@jrc03c/js-math-tools/src/log.mjs
   function log(x, base) {
     try {
       base = isUndefined(base) ? Math.E : base;
-      if (!isNumber(x))
-        return NaN;
-      if (!isNumber(base))
-        return NaN;
+      if (!isNumber(x)) return NaN;
+      if (!isNumber(base)) return NaN;
       if (typeof x === "bigint" || typeof base === "bigint") {
-        const out2 = log(Number(x), Number(base));
+        const out = log(Number(x), Number(base));
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
-          return out2;
+          return out;
         }
       }
       return Math.log(x) / Math.log(base);
@@ -3826,24 +3339,18 @@
     }
   }
   var vlog = vectorize(log);
-  function mean(arr, shouldDropNaNs) {
-    return stats(arr, { shouldDropNaNs }).mean;
-  }
-  function median(arr, shouldDropNaNs) {
-    return stats(arr, { shouldDropNaNs, median: true }).median;
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/mod.mjs
   function mod(a, b) {
     try {
-      if (!isNumber(a))
-        return NaN;
-      if (!isNumber(b))
-        return NaN;
+      if (!isNumber(a)) return NaN;
+      if (!isNumber(b)) return NaN;
       if (typeof a === "bigint" || typeof b === "bigint") {
-        const out2 = mod(Number(a), Number(b));
+        const out = mod(Number(a), Number(b));
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
-          return out2;
+          return out;
         }
       }
       return a % b;
@@ -3852,97 +3359,9 @@
     }
   }
   var vmod = vectorize(mod);
-  function mode(arr, shouldDropNaNs) {
-    return stats(arr, { shouldDropNaNs, mode: true }).mode;
-  }
-  function helper3() {
-    const u1 = random();
-    const u2 = random();
-    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-  }
-  function normal(shape2) {
-    if (isUndefined(shape2))
-      return helper3();
-    return vapply(ndarray(shape2), helper3);
-  }
-  function ones(shape2) {
-    return vapply(ndarray(shape2), () => 1);
-  }
-  function permutationsIterator(x, r) {
-    function* helper5(x2, r2) {
-      r2 = r2 || x2.length;
-      if (x2.length === 1) {
-        yield [x2];
-        return;
-      }
-      for (const c of combinations(x2, r2)) {
-        if (!c.slice)
-          continue;
-        const state = zeros(c.length);
-        yield c;
-        let i = 1;
-        while (i < c.length) {
-          if (state[i] < i) {
-            if (i % 2 === 0) {
-              const buf = c[0];
-              c[0] = c[i];
-              c[i] = buf;
-            } else {
-              const buf = c[state[i]];
-              c[state[i]] = c[i];
-              c[i] = buf;
-            }
-            yield c;
-            state[i] += 1;
-            i = 1;
-          } else {
-            state[i] = 0;
-            i += 1;
-          }
-        }
-      }
-    }
-    if (isDataFrame(x) || isSeries(x)) {
-      return permutationsIterator(x.values, r);
-    }
-    assert(isArray(x), "The `permutations` function only works on arrays, Series, and DataFrames!");
-    if (isUndefined(r)) {
-      r = x.length;
-    }
-    assert(isNumber(r) && vint(r) === r && r >= 0, "`r` must be a non-negative integer!");
-    return helper5(flatten(x), r);
-  }
-  function permutations(x, r) {
-    const out2 = [];
-    for (const perm of permutationsIterator(x, r)) {
-      out2.push(perm.slice());
-    }
-    return out2;
-  }
-  function print() {
-    Object.keys(arguments).forEach((key) => {
-      const x = arguments[key];
-      if (isArray(x)) {
-        if (!isJagged(x)) {
-          const xShape = shape(x);
-          if (xShape.length === 1) {
-            new Series(x).print();
-          } else if (xShape.length == 2) {
-            new DataFrame(x).print();
-          } else {
-            console.log(x);
-          }
-        } else {
-          console.log(x);
-        }
-      } else if (isDataFrame(x) || isSeries(x)) {
-        x.print();
-      } else {
-        console.log(x);
-      }
-    });
-  }
-  var helper4 = vectorize((x, a, b, c, d) => {
+
+  // node_modules/@jrc03c/js-math-tools/src/remap.mjs
+  var helper3 = vectorize((x, a, b, c, d) => {
     try {
       let resultShouldBeABigInt = false;
       for (const v of [x, a, b, c, d]) {
@@ -3962,62 +3381,50 @@
       }
       const num = (d - c) * (x - a);
       const den = b - a;
-      if (den === 0)
-        return NaN;
-      const out2 = num / den + c;
+      if (den === 0) return NaN;
+      const out = num / den + c;
       if (resultShouldBeABigInt) {
         try {
-          return BigInt(out2);
+          return BigInt(out);
         } catch (e) {
         }
       }
-      return out2;
+      return out;
     } catch (e) {
       return NaN;
     }
   });
-  function remap(x, a, b, c, d) {
-    if (isArray(x) && isUndefined(c) && isUndefined(d)) {
-      c = a;
-      d = b;
-      const results = stats(x);
-      a = results.min;
-      b = results.max;
-    }
-    return helper4(x, a, b, c, d);
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/round.mjs
   function round(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
-      if (typeof x === "bigint")
-        return x;
+      if (!isNumber(x)) return NaN;
+      if (typeof x === "bigint") return x;
       return Math.round(x);
     } catch (e) {
       return NaN;
     }
   }
   var vround = vectorize(round);
+
+  // node_modules/@jrc03c/js-math-tools/src/sign.mjs
   function sign(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
-      if (typeof x === "bigint")
-        return BigInt(sign(Number(x)));
-      if (x < 0)
-        return -1;
-      if (x > 0)
-        return 1;
+      if (!isNumber(x)) return NaN;
+      if (typeof x === "bigint") return BigInt(sign(Number(x)));
+      if (x < 0) return -1;
+      if (x > 0) return 1;
       return 0;
     } catch (e) {
       return NaN;
     }
   }
   var vsign = vectorize(sign);
+
+  // node_modules/@jrc03c/js-math-tools/src/sin.mjs
   function sin(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         x = Number(x);
       }
@@ -4027,35 +3434,11 @@
     }
   }
   var vsin = vectorize(sin);
-  function some(x, fn) {
-    if (isDataFrame(x) || isSeries(x)) {
-      return some(x.values, fn);
-    }
-    assert(isArray(x), "The first argument passed into the `some` function must be an array, Series, or DataFrame!");
-    assert(isFunction(fn), "The second argument passed into the `some` function must be a function!");
-    for (const v of x) {
-      if (isArray(v)) {
-        if (some(v, fn)) {
-          return true;
-        }
-      } else {
-        if (fn(v)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  function std(arr, shouldDropNaNs) {
-    return stats(arr, { shouldDropNaNs, stdev: true }).stdev;
-  }
-  function stdev(x) {
-    return std(x);
-  }
+
+  // node_modules/@jrc03c/js-math-tools/src/tan.mjs
   function tan(x) {
     try {
-      if (!isNumber(x))
-        return NaN;
+      if (!isNumber(x)) return NaN;
       if (typeof x === "bigint") {
         x = Number(x);
       }
@@ -4065,193 +3448,6 @@
     }
   }
   var vtan = vectorize(tan);
-  function timeSync(fn, args) {
-    assert(isFunction(fn), "`fn` must be a function!");
-    const start = /* @__PURE__ */ new Date();
-    if (args) {
-      fn(...args);
-    } else {
-      fn();
-    }
-    return /* @__PURE__ */ new Date() - start;
-  }
-  async function timeAsync(fn, args) {
-    assert(isFunction(fn), "`fn` must be a function!");
-    const start = /* @__PURE__ */ new Date();
-    if (args) {
-      await fn(...args);
-    } else {
-      await fn();
-    }
-    return /* @__PURE__ */ new Date() - start;
-  }
-  function union() {
-    return set([...arguments].map((v) => {
-      if (isArray(v))
-        return v;
-      if (isDataFrame(v))
-        return v.values;
-      if (isSeries(v))
-        return v.values;
-      return [v];
-    }));
-  }
-  function variance(arr, shouldDropNaNs) {
-    return stats(arr, { shouldDropNaNs, variance: true }).variance;
-  }
-  function zip() {
-    const out2 = [];
-    const arrays = Object.values(arguments).map((arr) => {
-      if (isDataFrame(arr) || isSeries(arr)) {
-        arr = arr.values;
-      }
-      assert(isArray(arr), "The `zip` function only works on arrays, Series, and DataFrames!");
-      return arr;
-    });
-    range(0, max(arrays.map((arr) => arr.length))).forEach((i) => {
-      const row = [];
-      arrays.forEach((arr) => {
-        const value = arr[i];
-        row.push(isUndefined(value) ? void 0 : value);
-      });
-      out2.push(row);
-    });
-    return out2;
-  }
-  var out = {
-    abs: vabs,
-    add: vadd,
-    apply: vapply,
-    arccos: varccos,
-    arcsin: varcsin,
-    arctan: varctan,
-    argmax,
-    argmin,
-    assert,
-    cast,
-    ceil: vceil,
-    chop: vchop,
-    clamp: vclamp,
-    combinations,
-    combinationsIterator,
-    copy,
-    correl,
-    cos: vcos,
-    count,
-    covariance,
-    DataFrame,
-    dataTypes,
-    decycle,
-    diff,
-    distance,
-    divide,
-    dot,
-    dropMissing,
-    dropMissingPairwise,
-    dropNaN,
-    dropNaNPairwise,
-    dropUndefined,
-    every,
-    exp: vexp,
-    factorial: vfactorial,
-    find,
-    findAll,
-    flatten,
-    float: vfloat,
-    floor: vfloor,
-    identity,
-    IndexMatcher,
-    indexOf,
-    inferType,
-    int: vint,
-    intersect,
-    inverse,
-    isArray,
-    isBoolean,
-    isBrowser: isBrowser2,
-    isDataFrame,
-    isDate,
-    isEqual,
-    isFunction,
-    isJagged,
-    isNested,
-    isNumber,
-    isObject,
-    isSeries,
-    isString,
-    isUndefined,
-    lerp: vlerp,
-    log: vlog,
-    MathError,
-    max,
-    mean,
-    median,
-    min,
-    mod: vmod,
-    mode,
-    multiply: vmultiply,
-    ndarray,
-    normal,
-    ones,
-    permutations,
-    permutationsIterator,
-    pow: vpow,
-    print,
-    product,
-    random,
-    range,
-    remap,
-    reshape,
-    reverse,
-    round: vround,
-    scale,
-    seed,
-    Series,
-    set,
-    shape,
-    shuffle,
-    sign: vsign,
-    sin: vsin,
-    some,
-    sort,
-    sqrt: vsqrt,
-    stats,
-    std,
-    stdev,
-    subtract,
-    sum,
-    tan: vtan,
-    timeAsync,
-    timeSync,
-    time: timeSync,
-    transpose,
-    union,
-    variance,
-    vectorize,
-    zeros,
-    zip,
-    dump() {
-      const context = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : void 0;
-      if (!context) {
-        throw new out.MathError("Cannot dump functions into global scope because none of `globalThis`, `global`, `window`, or `self` exist in the current context!");
-      }
-      Object.keys(out).forEach((key) => {
-        try {
-          Object.defineProperty(context, key, {
-            configurable: false,
-            enumerable: true,
-            writable: false,
-            value: out[key]
-          });
-        } catch (e) {
-          context[key] = out[key];
-        }
-      });
-    }
-  };
-  if (typeof window !== "undefined") {
-    window.JSMathTools = out;
-  }
 
   // src/index.mjs
   function makeKey4(keyLength, keySeed, charset) {
@@ -4277,12 +3473,12 @@
     if (charset) {
       assert(isString(charset), "`charset` must be a string!");
     }
-    let out2 = "";
+    let out = "";
     charset = charset || "abcdefg1234567890";
     for (let i = 0; i < keyLength; i++) {
-      out2 += charset[vint(random() * charset.length)];
+      out += charset[vint(random() * charset.length)];
     }
-    return out2;
+    return out;
   }
 
   // src/iife.mjs