@hairy/utils 1.39.0 → 1.39.1

package/dist/index.global.js

@@ -4483,192 +4483,6 @@
   var BigNumber = clone2();
   var bignumber_default = BigNumber;
 
-  // src/number/index.ts
-  var BIG_INTS = {
-    t: { v: 10 ** 12, d: 13, n: "t" },
-    b: { v: 10 ** 9, d: 10, n: "b" },
-    m: { v: 10 ** 6, d: 7, n: "m" },
-    k: { v: 10 ** 3, d: 4, n: "k" }
-  };
-  function bignum(n = "0") {
-    return new bignumber_default(numfix(n));
-  }
-  function numfix(value) {
-    return Number.isNaN(Number(value)) || value.toString() === "NaN" ? "0" : String(value);
-  }
-  function gte(a, b) {
-    return bignum(a).gte(bignum(b));
-  }
-  function gt(a, b) {
-    return bignum(a).gt(bignum(b));
-  }
-  function lte(a, b) {
-    return bignum(a).lte(bignum(b));
-  }
-  function lt(a, b) {
-    return bignum(a).lt(bignum(b));
-  }
-  function plus(array, options) {
-    const rounding = options?.r || bignumber_default.ROUND_DOWN;
-    const decimal2 = options?.d || 0;
-    return array.filter((v) => bignum(v).gt(0)).reduce((t, v) => t.plus(bignum(v)), bignum(0)).toFixed(decimal2, rounding);
-  }
-  function average(array, options) {
-    const rounding = options?.r || bignumber_default.ROUND_DOWN;
-    const decimal2 = options?.d || 0;
-    if (array.length === 0)
-      return "0";
-    return bignum(plus(array)).div(array.length).toFixed(decimal2, rounding);
-  }
-  function percentage(total, count, options) {
-    options ??= { d: 3, r: bignumber_default.ROUND_DOWN };
-    const rounding = options?.r || bignumber_default.ROUND_DOWN;
-    const decimal2 = options?.d || 3;
-    if (bignum(total).lte(0) || bignum(count).lte(0))
-      return "0";
-    return bignum(count).div(bignum(total)).times(100).toFixed(decimal2, rounding);
-  }
-  function zerofill(value, n = 2, type = "positive") {
-    const _value = integer(value);
-    if (_value.length >= n)
-      return value;
-    const zero = "0".repeat(n - _value.length);
-    if (type === "positive")
-      return zero + value;
-    if (type === "reverse")
-      return zero + value;
-    return "";
-  }
-  function zeromove(value) {
-    return value.toString().replace(/\.?0+$/, "");
-  }
-  function integer(value) {
-    return new bignumber_default(numfix(value)).toFixed(0);
-  }
-  function decimal(value, n = 2) {
-    let [integer2, decimal2] = numfix(value).split(".");
-    if (n <= 0)
-      return integer2;
-    if (!decimal2)
-      decimal2 = "0";
-    decimal2 = decimal2.slice(0, n);
-    decimal2 = decimal2 + "0".repeat(n - decimal2.length);
-    return `${integer2}.${decimal2}`;
-  }
-  function parseNumeric(num, delimiters = ["t", "b", "m"]) {
-    const mappings = [
-      delimiters.includes("t") && ((n) => gte(n, BIG_INTS.t.v) && BIG_INTS.t),
-      delimiters.includes("b") && ((n) => gte(n, BIG_INTS.b.v) && lt(n, BIG_INTS.t.v) && BIG_INTS.b),
-      delimiters.includes("m") && ((n) => gte(n, BIG_INTS.m.v) && lt(n, BIG_INTS.b.v) && BIG_INTS.m),
-      delimiters.includes("k") && ((n) => gte(n, BIG_INTS.k.v) && lt(n, BIG_INTS.m.v) && BIG_INTS.k)
-    ];
-    let options;
-    for (const analy of mappings) {
-      const opts = analy && analy(bignum(num).toFixed(0));
-      opts && (options = opts);
-    }
-    return options || { v: 1, d: 0, n: "" };
-  }
-  function formatNumeric(value = "0", options) {
-    if (options?.default && bignum(value).isZero())
-      return options?.default;
-    const {
-      rounding = bignumber_default.ROUND_DOWN,
-      delimiters,
-      format,
-      decimals = 2
-    } = options || {};
-    const config = parseNumeric(value, delimiters || []);
-    let number = bignum(value).div(config.v).toFormat(decimals, rounding, {
-      decimalSeparator: ".",
-      groupSeparator: ",",
-      groupSize: 3,
-      secondaryGroupSize: 0,
-      fractionGroupSeparator: " ",
-      fractionGroupSize: 0,
-      ...format
-    });
-    number = options?.zeromove ? zeromove(number) : number;
-    return `${number}${config.n}`;
-  }
-
-  // src/size/index.ts
-  function formatUnit(value, unit = "px") {
-    if (!(isString_default(value) || isNumber_default(value)))
-      return "";
-    value = String(value);
-    return /\D/.test(value) ? value : value + unit;
-  }
-  function formatSize(dimension, unit) {
-    const _formatUnit = (value) => formatUnit(value, unit);
-    if (typeof dimension === "string" || typeof dimension === "number")
-      return { width: _formatUnit(dimension), height: _formatUnit(dimension) };
-    if (Array.isArray(dimension))
-      return { width: _formatUnit(dimension[0]), height: _formatUnit(dimension[1]) };
-    if (typeof dimension === "object")
-      return { width: _formatUnit(dimension.width), height: _formatUnit(dimension.height) };
-    return { width: "", height: "" };
-  }
-
-  // src/string/index.ts
-  function cover(value, mode, symbol = "*") {
-    return value.slice(0, mode[0]) + symbol.repeat(mode[1]) + value.slice(-mode[2]);
-  }
-  function slash(str) {
-    return str.replace(/\\/g, "/");
-  }
-  function ensurePrefix(prefix, str) {
-    if (!str.startsWith(prefix))
-      return prefix + str;
-    return str;
-  }
-  function ensureSuffix(suffix, str) {
-    if (!str.endsWith(suffix))
-      return str + suffix;
-    return str;
-  }
-  function template(str, ...args) {
-    const [firstArg, fallback] = args;
-    if (isObject_default(firstArg)) {
-      const vars = firstArg;
-      return str.replace(/\{(\w+)\}/g, (_, key) => vars[key] || ((typeof fallback === "function" ? fallback(key) : fallback) ?? key));
-    } else {
-      return str.replace(/\{(\d+)\}/g, (_, key) => {
-        const index = Number(key);
-        if (Number.isNaN(index))
-          return key;
-        return args[index];
-      });
-    }
-  }
-  var _reFullWs = /^\s*$/;
-  function unindent(str) {
-    const lines = (typeof str === "string" ? str : str[0]).split("\n");
-    const whitespaceLines = lines.map((line) => _reFullWs.test(line));
-    const commonIndent = lines.reduce((min, line, idx) => {
-      if (whitespaceLines[idx])
-        return min;
-      const indent = line.match(/^\s*/)?.[0].length;
-      return indent === void 0 ? min : Math.min(min, indent);
-    }, Number.POSITIVE_INFINITY);
-    let emptyLinesHead = 0;
-    while (emptyLinesHead < lines.length && whitespaceLines[emptyLinesHead])
-      emptyLinesHead++;
-    let emptyLinesTail = 0;
-    while (emptyLinesTail < lines.length && whitespaceLines[lines.length - emptyLinesTail - 1])
-      emptyLinesTail++;
-    return lines.slice(emptyLinesHead, lines.length - emptyLinesTail).map((line) => line.slice(commonIndent)).join("\n");
-  }
-
-  // src/typeof/index.ts
-  function getTypeof(target) {
-    const value = Object.prototype.toString.call(target).slice(8, -1).toLocaleLowerCase();
-    return value;
-  }
-  function isTypeof(target, type) {
-    return getTypeof(target) === type;
-  }
-
   // src/util/compose-promise.ts
   function pCompose(...fns) {
     if (fns.length === 0)
@@ -4689,13 +4503,30 @@
   compose.promise = pCompose;
 
   // src/util/converts.ts
-  function formToObject(formData) {
+  function objectFromFormdata(formData) {
     return Object.fromEntries(formData.entries());
   }
-  function objectToForm(object) {
-    const formData = new FormData();
-    for (const [key, value] of Object.entries(object)) formData.append(key, value);
-    return formData;
+  function formdataFromObject(object) {
+    const formdata = new FormData();
+    for (const [key, value] of Object.entries(object))
+      formdata.set(key, value);
+    return formdata;
+  }
+  function nonnanable(value) {
+    return Number.isNaN(Number(value)) ? void 0 : value;
+  }
+  function numberify(value) {
+    return Number.isNaN(Number(value)) ? 0 : Number(value);
+  }
+  function stringify(value) {
+    return String(value);
+  }
+  function numberish(value) {
+    if (value === void 0 || value === null)
+      return "0";
+    if (Number.isNaN(Number(value)))
+      return "0";
+    return value.toString();
   }
 
   // src/util/noop.ts
@@ -4838,6 +4669,13 @@
     });
   }
 
+  // src/util/to-array.ts
+  function toArray(value) {
+    if (!value)
+      return void 0;
+    return Array.isArray(value) ? value : [value];
+  }
+
   // src/util/util.ts
   function arange(x1, x2, stp = 1, z = [], z0 = z.length) {
     if (!x2)
@@ -4862,6 +4700,202 @@
   function call(fn, ...args) {
     return fn(...args);
   }
+
+  // src/number/index.ts
+  var DEFAULT_BIGNUM_CONFIG = {
+    ROUNDING_MODE: bignumber_default.ROUND_UP,
+    DECIMAL_PLACES: 6
+  };
+  var BignumberCLONE = bignumber_default.clone(DEFAULT_BIGNUM_CONFIG);
+  var BIG_INTS = {
+    t: { v: 10 ** 12, d: 13, n: "t" },
+    b: { v: 10 ** 9, d: 10, n: "b" },
+    m: { v: 10 ** 6, d: 7, n: "m" },
+    k: { v: 10 ** 3, d: 4, n: "k" }
+  };
+  function bignumber(n = "0", base) {
+    return new BignumberCLONE(numberish(n), base);
+  }
+  bignumber.clone = function(config) {
+    return bignumber_default.clone({ ...DEFAULT_BIGNUM_CONFIG, ...config });
+  };
+  function gte(a, b) {
+    return bignumber(a).gte(bignumber(b));
+  }
+  function gt(a, b) {
+    return bignumber(a).gt(bignumber(b));
+  }
+  function lte(a, b) {
+    return bignumber(a).lte(bignumber(b));
+  }
+  function lt(a, b) {
+    return bignumber(a).lt(bignumber(b));
+  }
+  function plus(array, options) {
+    const rounding = options?.r || bignumber_default.ROUND_DOWN;
+    const decimal2 = options?.d || 0;
+    return array.filter((v) => bignumber(v).gt(0)).reduce((t, v) => t.plus(bignumber(v)), bignumber(0)).toFixed(decimal2, rounding);
+  }
+  function divs(array, options) {
+    const rounding = options?.r || bignumber_default.ROUND_DOWN;
+    const decimal2 = options?.d || 0;
+    return array.reduce((t, v) => t.div(bignumber(v)), bignumber(1)).toFixed(decimal2, rounding);
+  }
+  function average(array, options) {
+    const rounding = options?.r || bignumber_default.ROUND_DOWN;
+    const decimal2 = options?.d || 0;
+    if (array.length === 0)
+      return "0";
+    return bignumber(plus(array)).div(array.length).toFixed(decimal2, rounding);
+  }
+  function percentage(total, count, options) {
+    options ??= { d: 3, r: bignumber_default.ROUND_DOWN };
+    const rounding = options?.r || bignumber_default.ROUND_DOWN;
+    const decimal2 = options?.d || 3;
+    if (bignumber(total).lte(0) || bignumber(count).lte(0))
+      return "0";
+    return bignumber(count).div(bignumber(total)).times(100).toFixed(decimal2, rounding);
+  }
+  function zerofill(value, n = 2, type = "positive") {
+    const _value = integer(value);
+    if (_value.length >= n)
+      return value;
+    const zero = "0".repeat(n - _value.length);
+    if (type === "positive")
+      return zero + value;
+    if (type === "reverse")
+      return zero + value;
+    return "";
+  }
+  function zeromove(value) {
+    return numberish(value).toString().replace(/\.?0+$/, "");
+  }
+  function integer(value) {
+    return new bignumber_default(numberish(value)).toFixed(0);
+  }
+  function decimal(value, n = 2) {
+    let [integer2, decimal2] = numberish(value).split(".");
+    if (n <= 0)
+      return integer2;
+    if (!decimal2)
+      decimal2 = "0";
+    decimal2 = decimal2.slice(0, n);
+    decimal2 = decimal2 + "0".repeat(n - decimal2.length);
+    return `${integer2}.${decimal2}`;
+  }
+  function parseNumeric(num, delimiters = ["t", "b", "m"]) {
+    const mappings = [
+      delimiters.includes("t") && ((n) => gte(n, BIG_INTS.t.v) && BIG_INTS.t),
+      delimiters.includes("b") && ((n) => gte(n, BIG_INTS.b.v) && lt(n, BIG_INTS.t.v) && BIG_INTS.b),
+      delimiters.includes("m") && ((n) => gte(n, BIG_INTS.m.v) && lt(n, BIG_INTS.b.v) && BIG_INTS.m),
+      delimiters.includes("k") && ((n) => gte(n, BIG_INTS.k.v) && lt(n, BIG_INTS.m.v) && BIG_INTS.k)
+    ];
+    let options;
+    for (const analy of mappings) {
+      const opts = analy && analy(bignumber(num).toFixed(0));
+      opts && (options = opts);
+    }
+    return options || { v: 1, d: 0, n: "" };
+  }
+  function formatNumeric(value = "0", options) {
+    if (options?.default && bignumber(value).isZero())
+      return options?.default;
+    const {
+      rounding = bignumber_default.ROUND_DOWN,
+      delimiters,
+      format,
+      decimals = 2
+    } = options || {};
+    const config = parseNumeric(value, delimiters || []);
+    let number = bignumber(value).div(config.v).toFormat(decimals, rounding, {
+      decimalSeparator: ".",
+      groupSeparator: ",",
+      groupSize: 3,
+      secondaryGroupSize: 0,
+      fractionGroupSeparator: " ",
+      fractionGroupSize: 0,
+      ...format
+    });
+    number = options?.zeromove ? zeromove(number) : number;
+    return `${number}${config.n}`;
+  }
+
+  // src/size/index.ts
+  function formatUnit(value, unit = "px") {
+    if (!(isString_default(value) || isNumber_default(value)))
+      return "";
+    value = String(value);
+    return /\D/.test(value) ? value : value + unit;
+  }
+  function formatSize(dimension, unit) {
+    const _formatUnit = (value) => formatUnit(value, unit);
+    if (typeof dimension === "string" || typeof dimension === "number")
+      return { width: _formatUnit(dimension), height: _formatUnit(dimension) };
+    if (Array.isArray(dimension))
+      return { width: _formatUnit(dimension[0]), height: _formatUnit(dimension[1]) };
+    if (typeof dimension === "object")
+      return { width: _formatUnit(dimension.width), height: _formatUnit(dimension.height) };
+    return { width: "", height: "" };
+  }
+
+  // src/string/index.ts
+  function cover(value, mode, symbol = "*") {
+    return value.slice(0, mode[0]) + symbol.repeat(mode[1]) + value.slice(-mode[2]);
+  }
+  function slash(str) {
+    return str.replace(/\\/g, "/");
+  }
+  function ensurePrefix(prefix, str) {
+    if (!str.startsWith(prefix))
+      return prefix + str;
+    return str;
+  }
+  function ensureSuffix(suffix, str) {
+    if (!str.endsWith(suffix))
+      return str + suffix;
+    return str;
+  }
+  function template(str, ...args) {
+    const [firstArg, fallback] = args;
+    if (isObject_default(firstArg)) {
+      const vars = firstArg;
+      return str.replace(/\{(\w+)\}/g, (_, key) => vars[key] || ((typeof fallback === "function" ? fallback(key) : fallback) ?? key));
+    } else {
+      return str.replace(/\{(\d+)\}/g, (_, key) => {
+        const index = Number(key);
+        if (Number.isNaN(index))
+          return key;
+        return args[index];
+      });
+    }
+  }
+  var _reFullWs = /^\s*$/;
+  function unindent(str) {
+    const lines = (typeof str === "string" ? str : str[0]).split("\n");
+    const whitespaceLines = lines.map((line) => _reFullWs.test(line));
+    const commonIndent = lines.reduce((min, line, idx) => {
+      if (whitespaceLines[idx])
+        return min;
+      const indent = line.match(/^\s*/)?.[0].length;
+      return indent === void 0 ? min : Math.min(min, indent);
+    }, Number.POSITIVE_INFINITY);
+    let emptyLinesHead = 0;
+    while (emptyLinesHead < lines.length && whitespaceLines[emptyLinesHead])
+      emptyLinesHead++;
+    let emptyLinesTail = 0;
+    while (emptyLinesTail < lines.length && whitespaceLines[lines.length - emptyLinesTail - 1])
+      emptyLinesTail++;
+    return lines.slice(emptyLinesHead, lines.length - emptyLinesTail).map((line) => line.slice(commonIndent)).join("\n");
+  }
+
+  // src/typeof/index.ts
+  function getTypeof(target) {
+    const value = Object.prototype.toString.call(target).slice(8, -1).toLocaleLowerCase();
+    return value;
+  }
+  function isTypeof(target, type) {
+    return getTypeof(target) === type;
+  }
 })();
 /*! Bundled license information: