full-utils 1.0.11 → 2.0.0

package/dist/index.js

@@ -1,100 +1,978 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.netTCP = exports.toRangeip = exports.toSqlUpdateMany = exports.toUndefined = exports.toNull = exports.toTrim = exports.toPoolName = exports.toLower = exports.toPhone = exports.toJSON = exports.toArrFuncArgs = exports.toDateStr = exports.toTimestamp = exports.toPortions = exports.toNum = exports.toInetNtoa = exports.toInetAton = exports.toH = exports.toGH = exports.toGB = exports.toCellDate = exports.toBool = exports.isVar = exports.isStrOrderType = exports.isStrFilled = exports.isStrBool = exports.isStr = exports.isPhone = exports.isPassword = exports.isObjFilled = exports.isObj = exports.isNumPZ = exports.isNumP = exports.isNumNZ = exports.isNumN = exports.isNumFloat = exports.isNum = exports.isMac = exports.isIp = exports.isFunc = exports.isExists = exports.isEmail = exports.isDate = exports.isBool = exports.isArrFilled = exports.isArr = exports.fromTimestamp = exports.fromJSON = void 0;
-const fromJSON_1 = require("./src/from/fromJSON");
-Object.defineProperty(exports, "fromJSON", { enumerable: true, get: function () { return fromJSON_1.fromJSON; } });
-const fromTimestamp_1 = require("./src/from/fromTimestamp");
-Object.defineProperty(exports, "fromTimestamp", { enumerable: true, get: function () { return fromTimestamp_1.fromTimestamp; } });
-const isArr_1 = require("./src/is/isArr");
-Object.defineProperty(exports, "isArr", { enumerable: true, get: function () { return isArr_1.isArr; } });
-const isArrFilled_1 = require("./src/is/isArrFilled");
-Object.defineProperty(exports, "isArrFilled", { enumerable: true, get: function () { return isArrFilled_1.isArrFilled; } });
-const isBool_1 = require("./src/is/isBool");
-Object.defineProperty(exports, "isBool", { enumerable: true, get: function () { return isBool_1.isBool; } });
-const isDate_1 = require("./src/is/isDate");
-Object.defineProperty(exports, "isDate", { enumerable: true, get: function () { return isDate_1.isDate; } });
-const isEmail_1 = require("./src/is/isEmail");
-Object.defineProperty(exports, "isEmail", { enumerable: true, get: function () { return isEmail_1.isEmail; } });
-const isExists_1 = require("./src/is/isExists");
-Object.defineProperty(exports, "isExists", { enumerable: true, get: function () { return isExists_1.isExists; } });
-const isFunc_1 = require("./src/is/isFunc");
-Object.defineProperty(exports, "isFunc", { enumerable: true, get: function () { return isFunc_1.isFunc; } });
-const isIp_1 = require("./src/is/isIp");
-Object.defineProperty(exports, "isIp", { enumerable: true, get: function () { return isIp_1.isIp; } });
-const isMac_1 = require("./src/is/isMac");
-Object.defineProperty(exports, "isMac", { enumerable: true, get: function () { return isMac_1.isMac; } });
-const isNum_1 = require("./src/is/isNum");
-Object.defineProperty(exports, "isNum", { enumerable: true, get: function () { return isNum_1.isNum; } });
-const isNumFloat_1 = require("./src/is/isNumFloat");
-Object.defineProperty(exports, "isNumFloat", { enumerable: true, get: function () { return isNumFloat_1.isNumFloat; } });
-const isNumN_1 = require("./src/is/isNumN");
-Object.defineProperty(exports, "isNumN", { enumerable: true, get: function () { return isNumN_1.isNumN; } });
-const isNumNZ_1 = require("./src/is/isNumNZ");
-Object.defineProperty(exports, "isNumNZ", { enumerable: true, get: function () { return isNumNZ_1.isNumNZ; } });
-const isNumP_1 = require("./src/is/isNumP");
-Object.defineProperty(exports, "isNumP", { enumerable: true, get: function () { return isNumP_1.isNumP; } });
-const isNumPZ_1 = require("./src/is/isNumPZ");
-Object.defineProperty(exports, "isNumPZ", { enumerable: true, get: function () { return isNumPZ_1.isNumPZ; } });
-const isObj_1 = require("./src/is/isObj");
-Object.defineProperty(exports, "isObj", { enumerable: true, get: function () { return isObj_1.isObj; } });
-const isObjFilled_1 = require("./src/is/isObjFilled");
-Object.defineProperty(exports, "isObjFilled", { enumerable: true, get: function () { return isObjFilled_1.isObjFilled; } });
-const isPassword_1 = require("./src/is/isPassword");
-Object.defineProperty(exports, "isPassword", { enumerable: true, get: function () { return isPassword_1.isPassword; } });
-const isPhone_1 = require("./src/is/isPhone");
-Object.defineProperty(exports, "isPhone", { enumerable: true, get: function () { return isPhone_1.isPhone; } });
-const isStr_1 = require("./src/is/isStr");
-Object.defineProperty(exports, "isStr", { enumerable: true, get: function () { return isStr_1.isStr; } });
-const isStrBool_1 = require("./src/is/isStrBool");
-Object.defineProperty(exports, "isStrBool", { enumerable: true, get: function () { return isStrBool_1.isStrBool; } });
-const isStrFilled_1 = require("./src/is/isStrFilled");
-Object.defineProperty(exports, "isStrFilled", { enumerable: true, get: function () { return isStrFilled_1.isStrFilled; } });
-const isStrOrderType_1 = require("./src/is/isStrOrderType");
-Object.defineProperty(exports, "isStrOrderType", { enumerable: true, get: function () { return isStrOrderType_1.isStrOrderType; } });
-const isVar_1 = require("./src/is/isVar");
-Object.defineProperty(exports, "isVar", { enumerable: true, get: function () { return isVar_1.isVar; } });
-const toBool_1 = require("./src/to/toBool");
-Object.defineProperty(exports, "toBool", { enumerable: true, get: function () { return toBool_1.toBool; } });
-const toCellDate_1 = require("./src/to/toCellDate");
-Object.defineProperty(exports, "toCellDate", { enumerable: true, get: function () { return toCellDate_1.toCellDate; } });
-const toGB_1 = require("./src/to/toGB");
-Object.defineProperty(exports, "toGB", { enumerable: true, get: function () { return toGB_1.toGB; } });
-const toGH_1 = require("./src/to/toGH");
-Object.defineProperty(exports, "toGH", { enumerable: true, get: function () { return toGH_1.toGH; } });
-const toH_1 = require("./src/to/toH");
-Object.defineProperty(exports, "toH", { enumerable: true, get: function () { return toH_1.toH; } });
-const toInetAton_1 = require("./src/to/toInetAton");
-Object.defineProperty(exports, "toInetAton", { enumerable: true, get: function () { return toInetAton_1.toInetAton; } });
-const toInetNtoa_1 = require("./src/to/toInetNtoa");
-Object.defineProperty(exports, "toInetNtoa", { enumerable: true, get: function () { return toInetNtoa_1.toInetNtoa; } });
-const toNum_1 = require("./src/to/toNum");
-Object.defineProperty(exports, "toNum", { enumerable: true, get: function () { return toNum_1.toNum; } });
-const toPortions_1 = require("./src/to/toPortions");
-Object.defineProperty(exports, "toPortions", { enumerable: true, get: function () { return toPortions_1.toPortions; } });
-const toTimestamp_1 = require("./src/to/toTimestamp");
-Object.defineProperty(exports, "toTimestamp", { enumerable: true, get: function () { return toTimestamp_1.toTimestamp; } });
-const toDateStr_1 = require("./src/to/toDateStr");
-Object.defineProperty(exports, "toDateStr", { enumerable: true, get: function () { return toDateStr_1.toDateStr; } });
-const toArrFuncArgs_1 = require("./src/to/toArrFuncArgs");
-Object.defineProperty(exports, "toArrFuncArgs", { enumerable: true, get: function () { return toArrFuncArgs_1.toArrFuncArgs; } });
-const toJSON_1 = require("./src/to/toJSON");
-Object.defineProperty(exports, "toJSON", { enumerable: true, get: function () { return toJSON_1.toJSON; } });
-const toPhone_1 = require("./src/to/toPhone");
-Object.defineProperty(exports, "toPhone", { enumerable: true, get: function () { return toPhone_1.toPhone; } });
-const toLower_1 = require("./src/to/toLower");
-Object.defineProperty(exports, "toLower", { enumerable: true, get: function () { return toLower_1.toLower; } });
-const toPoolName_1 = require("./src/to/toPoolName");
-Object.defineProperty(exports, "toPoolName", { enumerable: true, get: function () { return toPoolName_1.toPoolName; } });
-const toTrim_1 = require("./src/to/toTrim");
-Object.defineProperty(exports, "toTrim", { enumerable: true, get: function () { return toTrim_1.toTrim; } });
-const toNull_1 = require("./src/to/toNull");
-Object.defineProperty(exports, "toNull", { enumerable: true, get: function () { return toNull_1.toNull; } });
-const toUndefined_1 = require("./src/to/toUndefined");
-Object.defineProperty(exports, "toUndefined", { enumerable: true, get: function () { return toUndefined_1.toUndefined; } });
-const toSqlUpdateMany_1 = require("./src/to/toSqlUpdateMany");
-Object.defineProperty(exports, "toSqlUpdateMany", { enumerable: true, get: function () { return toSqlUpdateMany_1.toSqlUpdateMany; } });
-const toRangeip_1 = require("./src/to/toRangeip");
-Object.defineProperty(exports, "toRangeip", { enumerable: true, get: function () { return toRangeip_1.toRangeip; } });
-const netTCP_1 = require("./src/net/netTCP");
-Object.defineProperty(exports, "netTCP", { enumerable: true, get: function () { return netTCP_1.netTCP; } });
+// src/arr/formatStrToFuncArgs.ts
+function formatStrToFuncArgs(value) {
+  if (!isStr(value)) {
+    return [value];
+  }
+  let src = value.trim();
+  if (src === "") {
+    return [];
+  }
+  if (src.startsWith("[") && src.endsWith("]")) {
+    src = src.slice(1, -1).trim();
+    if (src === "") {
+      return [];
+    }
+  }
+  let buf = "", inQuote = false, quoteChar = null, esc = false, depthParen = 0, depthBracket = 0, depthBrace = 0;
+  const items = [];
+  const finalize = () => {
+    const trimmed = buf.trim();
+    if (trimmed !== "") {
+      items.push(trimmed);
+    }
+    buf = "";
+  };
+  for (let i = 0; i < src.length; i++) {
+    const ch = src[i];
+    if (inQuote) {
+      buf += ch;
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (ch === "\\") {
+        esc = true;
+        continue;
+      }
+      if (ch === quoteChar) {
+        inQuote = false;
+        quoteChar = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = true;
+      quoteChar = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "(") {
+      depthParen++;
+      buf += ch;
+      continue;
+    }
+    if (ch === ")") {
+      depthParen = Math.max(0, depthParen - 1);
+      buf += ch;
+      continue;
+    }
+    if (ch === "[") {
+      depthBracket++;
+      buf += ch;
+      continue;
+    }
+    if (ch === "]") {
+      depthBracket = Math.max(0, depthBracket - 1);
+      buf += ch;
+      continue;
+    }
+    if (ch === "{") {
+      depthBrace++;
+      buf += ch;
+      continue;
+    }
+    if (ch === "}") {
+      depthBrace = Math.max(0, depthBrace - 1);
+      buf += ch;
+      continue;
+    }
+    if (ch === "," && depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
+      finalize();
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.length) {
+    finalize();
+  }
+  return items.map((raw) => {
+    if (raw.startsWith("$") && raw.includes("(") && raw.endsWith(")")) {
+      return raw;
+    }
+    if (raw === "null") {
+      return null;
+    }
+    if (raw === "undefined") {
+      return void 0;
+    }
+    if (isStrBool(raw)) {
+      return formatToBool(raw);
+    }
+    const n = formatToNum(raw);
+    if (Number.isFinite(n)) {
+      return n;
+    }
+    if (raw === "Infinity") {
+      return Infinity;
+    }
+    if (raw === "-Infinity") {
+      return -Infinity;
+    }
+    const rawStr = String(raw || "");
+    const hasQuotes = rawStr.length >= 2 && (rawStr.startsWith("'") && rawStr.endsWith("'") || rawStr.startsWith('"') && rawStr.endsWith('"'));
+    if (hasQuotes) {
+      return rawStr.slice(1, -1).replace(/\\\\/g, "\\").replace(/\\'/g, "'").replace(/\\"/g, '"');
+    }
+    if (rawStr.startsWith("{") && rawStr.endsWith("}") || rawStr.startsWith("[") && rawStr.endsWith("]")) {
+      try {
+        return jsonDecode(rawStr);
+      } catch {
+      }
+    }
+    return rawStr;
+  });
+}
+
+// src/arr/splitArrToPortions.ts
+function splitArrToPortions(arr, portionLength) {
+  if (!Number.isInteger(portionLength) || portionLength <= 0) {
+    return [];
+  }
+  const out = [];
+  let i = 0;
+  while (i < arr.length) {
+    out.push(arr.slice(i, i + portionLength));
+    i += portionLength;
+  }
+  return out;
+}
+
+// src/bool/formatToBool.ts
+function formatToBool(value) {
+  switch (true) {
+    case isBool(value):
+      return value;
+    case isNumP(value):
+      return true;
+    case isNumNZ(value):
+      return false;
+    case (isStrFilled(value) && ["true", "1", "yes", "on"].includes(String(value ?? "").trim().toLowerCase())):
+      return true;
+    case (isStrFilled(value) && ["false", "0", "no", "off"].includes(String(value ?? "").trim().toLowerCase())):
+      return false;
+  }
+  return false;
+}
+
+// src/common/wait.ts
+async function wait(timeout = 0) {
+  await new Promise((resolve) => setTimeout(() => resolve(true), timeout));
+}
+
+// src/date/floorDateToMinutes.ts
+function floorDateToMinutes(everyMinutes = 1, date = /* @__PURE__ */ new Date()) {
+  const step = Math.min(60, Math.max(1, Math.trunc(Math.abs(everyMinutes))));
+  const m = date.getMinutes();
+  const floored = Math.floor(m / step) * step;
+  const d = new Date(date);
+  d.setMinutes(floored, 0, 0);
+  return d;
+}
+
+// src/date/formatDateToString.ts
+function formatDateToString(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+
+// src/date/partsToSeconds.ts
+function partsToSeconds(parts) {
+  const { days = 0, hours = 0, minutes = 0, seconds = 0 } = parts;
+  return days * 86400 + hours * 3600 + minutes * 60 + seconds;
+}
+
+// src/date/secondsToParts.ts
+function secondsToParts(total) {
+  if (!Number.isFinite(total) || total < 0) {
+    throw new Error("Invalid total seconds");
+  }
+  const days = Math.floor(total / 86400);
+  const hours = Math.floor(total % 86400 / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const seconds = total % 60;
+  return { days, hours, minutes, seconds };
+}
+
+// src/ip-addr/cidrToRange.ts
+function cidrToRange(cidr) {
+  const [ip, maskStr] = cidr.split("/");
+  const base = parseIPv4(ip);
+  const mask = maskStr ? Number(maskStr) : NaN;
+  if (base === null || !Number.isInteger(mask) || mask < 0 || mask > 32) {
+    return null;
+  }
+  const netmask = mask === 0 ? 0 : 4294967295 << 32 - mask >>> 0;
+  const start = base & netmask;
+  const end = start | ~netmask >>> 0;
+  return [toIPv4(start), toIPv4(end)];
+}
+
+// src/ip-addr/ipAddrToNum.ts
+function ipAddrToNum(ip) {
+  const parts = ip.split(".").map((p) => Number(p));
+  if (parts.length !== 4 || parts.some((p) => !Number.isInteger(p) || p < 0 || p > 255)) {
+    throw new Error("Invalid IPv4 address");
+  }
+  const buffer = new ArrayBuffer(4);
+  const dv = new DataView(buffer);
+  let i = 0;
+  while (i < 4) {
+    dv.setUint8(i, parts[i]);
+    i++;
+  }
+  return dv.getUint32(0, false);
+}
+
+// src/ip-addr/numToIpAddr.ts
+function numToIpAddr(num) {
+  if (!isNumP(num)) {
+    return "";
+  }
+  const nbuffer = new ArrayBuffer(4);
+  const ndv = new DataView(nbuffer);
+  ndv.setUint32(0, num, false);
+  const output = [];
+  let i = 0;
+  while (i < 4) {
+    output.push(ndv.getUint8(i));
+    i++;
+  }
+  return output.join(".");
+}
+
+// src/ip-addr/parseIPv4.ts
+function parseIPv4(ip) {
+  if (!isStr(ip)) {
+    return null;
+  }
+  const parts = formatToTrim(ip).split(".");
+  if (parts.length !== 4) {
+    return null;
+  }
+  let out = 0;
+  for (let i = 0; i < 4; i++) {
+    if (!/^\d{1,3}$/.test(parts[i])) {
+      return null;
+    }
+    const n = Number(parts[i]);
+    if (n < 0 || n > 255) {
+      return null;
+    }
+    out = out << 8 | n;
+  }
+  return out >>> 0;
+}
+
+// src/ip-addr/rangeIPv4.ts
+function* rangeIPv4(from, to, opts = {}) {
+  const { includeNetwork = true, includeBroadcast = true } = opts;
+  let startNum;
+  let endNum;
+  let isCIDR = false;
+  let cidrMask = null;
+  if (to === void 0 && from.includes("/")) {
+    const range = cidrToRange(from);
+    if (!range) {
+      throw new Error(`Invalid CIDR: "${from}"`);
+    }
+    const [startStr, endStr] = range;
+    const [_, maskStr] = from.split("/");
+    cidrMask = Number(maskStr);
+    startNum = parseIPv4(startStr);
+    endNum = parseIPv4(endStr);
+    isCIDR = true;
+  } else {
+    const s = parseIPv4(from);
+    if (s === null) {
+      throw new Error(`Invalid IPv4: "${from}"`);
+    }
+    startNum = s;
+    if (to && to.trim() !== "") {
+      const e = parseIPv4(to);
+      if (e === null) {
+        throw new Error(`Invalid IPv4: "${to}"`);
+      }
+      endNum = e;
+    } else {
+      const a = startNum >>> 24 & 255;
+      const b = startNum >>> 16 & 255;
+      const c = startNum >>> 8 & 255;
+      endNum = (a << 24 | b << 16 | c << 8 | 255) >>> 0;
+    }
+  }
+  if (startNum > endNum) {
+    [startNum, endNum] = [endNum, startNum];
+  }
+  let skipNetworkAt = -1;
+  let skipBroadcastAt = -1;
+  if (isCIDR && cidrMask !== null) {
+    if (cidrMask <= 30) {
+      skipNetworkAt = startNum;
+      skipBroadcastAt = endNum;
+    }
+  }
+  for (let cur = startNum; cur <= endNum; cur = cur + 1 >>> 0) {
+    if (!includeNetwork && cur === skipNetworkAt) {
+      if (cur === endNum) {
+        break;
+      }
+      continue;
+    }
+    if (!includeBroadcast && cur === skipBroadcastAt) {
+      if (cur === endNum) {
+        break;
+      }
+      continue;
+    }
+    yield toIPv4(cur);
+    if (cur === 4294967295) {
+      break;
+    }
+  }
+}
+
+// src/ip-addr/rangeIPv4ToArr.ts
+function rangeIPv4ToArr2(from, to, opts = {}) {
+  const { limit = 1e6 } = opts;
+  const out = [];
+  let count = 0;
+  for (const ip of rangeIPv4(from, to, opts)) {
+    if (count >= limit) {
+      throw new Error(`Range is too large (> ${limit}). Use the generator version instead.`);
+    }
+    out.push(ip);
+    count++;
+  }
+  return out;
+}
+
+// src/ip-addr/toIPv4.ts
+function toIPv4(n) {
+  if (!Number.isInteger(n) || n < 0 || n > 4294967295) {
+    throw new Error(`Invalid IPv4 number: ${n}`);
+  }
+  return [
+    n >>> 24 & 255,
+    n >>> 16 & 255,
+    n >>> 8 & 255,
+    n & 255
+  ].join(".");
+}
+
+// src/is/isArr.ts
+function isArr(value) {
+  return Array.isArray(value);
+}
+
+// src/is/isArrFilled.ts
+function isArrFilled(value) {
+  return isArr(value) && value.length > 0;
+}
+
+// src/is/isBool.ts
+function isBool(value) {
+  return typeof value === "boolean";
+}
+
+// src/is/isDate.ts
+function isDate(value) {
+  if (value instanceof Date) {
+    return !Number.isNaN(value.getTime());
+  }
+  if (isStr(value) || isNum(value)) {
+    const d = new Date(value);
+    return !Number.isNaN(d.getTime());
+  }
+  return false;
+}
+
+// src/is/isEmail.ts
+var emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z]{2,})+$/;
+function isEmail(value) {
+  if (!isStrFilled(value)) {
+    return false;
+  }
+  return emailRegex.test(value);
+}
+
+// src/is/isExists.ts
+function isExists(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/is/isFunc.ts
+function isFunc(value) {
+  return typeof value === "function";
+}
+
+// src/is/isIpAddr.ts
+var IPV4_RE = /^(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+function isIpAddr(value) {
+  if (!isStr(value)) {
+    return false;
+  }
+  const v = value.trim();
+  return IPV4_RE.test(v);
+}
+
+// src/is/isMacAddr.ts
+function isMacAddr(value) {
+  return isStr(value) && /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/.test(value);
+}
+
+// src/is/isNum.ts
+function isNum(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/is/isNumFloat.ts
+function isNumFloat(value) {
+  return isNum(value) && !Number.isInteger(value);
+}
+
+// src/is/isNumN.ts
+function isNumN(value) {
+  return isNum(value) && value < 0;
+}
+
+// src/is/isNumNZ.ts
+function isNumNZ(value) {
+  return isNum(value) && value <= 0;
+}
+
+// src/is/isNumP.ts
+function isNumP(value) {
+  return isNum(value) && value > 0;
+}
+
+// src/is/isNumPZ.ts
+function isNumPZ(value) {
+  return isNum(value) && value >= 0;
+}
+
+// src/is/isObj.ts
+function isObj(value) {
+  return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === "[object Object]" && !Array.isArray(value);
+}
+
+// src/is/isObjFilled.ts
+function isObjFilled(value) {
+  return isObj(value) && Object.keys(value).length > 0;
+}
+
+// src/is/isPassword.ts
+function isPassword(value, {
+  minLength = 8,
+  maxLength = 256,
+  requireUppercase = true,
+  requireLowercase = true,
+  requireDigit = true,
+  requireSpecial = true
+} = {}) {
+  if (!isStr(value)) {
+    return false;
+  }
+  if (value.length < minLength || value.length > maxLength) {
+    return false;
+  }
+  if (requireUppercase && !/[A-ZА-Я]/.test(value)) {
+    return false;
+  }
+  if (requireLowercase && !/[a-zа-я]/.test(value)) {
+    return false;
+  }
+  if (requireDigit && !/\d/.test(value)) {
+    return false;
+  }
+  if (requireSpecial && !/[~!?@#$%^&*_\-+()\[\]{}><\\\/|"'.,:;=]/.test(value)) {
+    return false;
+  }
+  return true;
+}
+
+// src/is/isPhone.ts
+function isPhone(value) {
+  if (!isStrFilled(value) && !isNum(value)) {
+    return false;
+  }
+  const valueProcessed = String(value).trim();
+  if (valueProcessed.startsWith("-")) {
+    return false;
+  }
+  if ((valueProcessed.match(/\+/g) || []).length > 1) {
+    return false;
+  }
+  if (valueProcessed.includes("+") && !valueProcessed.startsWith("+")) {
+    return false;
+  }
+  if (!/^\+?[0-9-]+$/.test(valueProcessed)) {
+    return false;
+  }
+  if (valueProcessed.length < 3 || valueProcessed.length > 20) {
+    return false;
+  }
+  if (!/[0-9]$/.test(valueProcessed)) {
+    return false;
+  }
+  if (valueProcessed.includes("--")) {
+    return false;
+  }
+  return true;
+}
+
+// src/is/isStr.ts
+function isStr(value) {
+  return typeof value === "string";
+}
+
+// src/is/isStrBool.ts
+function isStrBool(value) {
+  if (!isStrFilled(value)) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "true" || normalized === "false";
+}
+
+// src/is/isStrFilled.ts
+function isStrFilled(value) {
+  return isStr(value) && value.trim().length > 0;
+}
+
+// src/is/isStrAscDesc.ts
+function isStrAscDesc(value) {
+  if (!isStrFilled(value)) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "asc" || normalized === "desc";
+}
+
+// src/is/isVar.ts
+function isVar(value) {
+  return isStr(value) && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+
+// src/json/parseStringLike.ts
+var QUOTED_RE = /^(['"`])([\s\S]*)\1$/;
+function parseStringLike(s, allowString) {
+  const trimmed = s.trim();
+  const pr = tryParseJSON(trimmed);
+  if (pr.ok) {
+    return pr.value;
+  }
+  const m = QUOTED_RE.exec(trimmed);
+  if (m) {
+    return m[2];
+  }
+  return allowString ? trimmed : null;
+}
+
+// src/json/tryParseJSON.ts
+function tryParseJSON(str) {
+  try {
+    return { ok: true, value: JSON.parse(str) };
+  } catch (err) {
+  }
+  return { ok: false };
+}
+
+// src/json/jsonDecode.ts
+function jsonDecode(value, allowString = false) {
+  if (value === null || isNum(value) || isBool(value)) {
+    return value;
+  }
+  if (isArrFilled(value)) {
+    const arr = value;
+    const out = [];
+    for (const item of arr) {
+      if (isStrFilled(item)) {
+        out.push(parseStringLike(String(item), allowString));
+      } else {
+        out.push(item);
+      }
+    }
+    return out;
+  }
+  if (isObjFilled(value)) {
+    const src = value;
+    const out = {};
+    for (const key of Object.keys(src)) {
+      const v = src[key];
+      if (isStrFilled(v)) {
+        out[key] = parseStringLike(String(v), allowString);
+      } else {
+        out[key] = v;
+      }
+    }
+    return out;
+  }
+  if (isArr(value) || isObj(value)) {
+    return value;
+  }
+  if (isStrFilled(value)) {
+    return parseStringLike(String(value), allowString);
+  }
+  return null;
+}
+
+// src/json/jsonEncode.ts
+function jsonEncode2(value) {
+  try {
+    return isObj(value) || isArr(value) ? JSON.stringify(value) : "";
+  } catch (err) {
+  }
+  return "";
+}
+
+// src/num/changeFixedDecimalScale.ts
+function changeFixedDecimalScale(value, scaleDelta) {
+  const delta = Math.trunc(scaleDelta);
+  if (delta === 0) {
+    return { ...value };
+  }
+  if (delta > 0) {
+    return {
+      sign: value.sign,
+      digitsInteger: value.digitsInteger,
+      scale: value.scale + delta
+    };
+  }
+  const multiplier = 10n ** BigInt(-delta);
+  return {
+    sign: value.sign,
+    digitsInteger: value.digitsInteger * multiplier,
+    scale: value.scale + delta
+  };
+}
+
+// src/num/convertExponentialToParts.ts
+function convertExponentialToParts(sign, exponentialString) {
+  const match = /^([0-9]+)(?:\.([0-9]*))?e([+\-]?[0-9]+)$/i.exec(
+    (() => {
+      const [coefficient, exponentText] = exponentialString.split(/e/i);
+      const [integerPart, fractionalPart = ""] = coefficient.split(".");
+      const allDigits2 = integerPart.replace(/^0+/, "") + fractionalPart;
+      const exponentValue = parseInt(exponentText, 10) - fractionalPart.length;
+      return `${allDigits2 || "0"}e${exponentValue}`;
+    })()
+  );
+  if (!match) {
+    throw new Error("Failed to parse exponential notation.");
+  }
+  let allDigits = match[1];
+  const exponent = parseInt(match[3], 10);
+  if (isNumPZ(exponent)) {
+    allDigits = allDigits + "0".repeat(exponent);
+    return {
+      sign,
+      integerPart: allDigits || "0",
+      fractionalPart: ""
+    };
+  } else {
+    const digitsToLeft = -exponent;
+    if (digitsToLeft >= allDigits.length) {
+      const missingZeros = "0".repeat(digitsToLeft - allDigits.length);
+      return {
+        sign,
+        integerPart: "0",
+        fractionalPart: missingZeros + allDigits
+      };
+    } else {
+      const splitIndex = allDigits.length - digitsToLeft;
+      return {
+        sign,
+        integerPart: allDigits.slice(0, splitIndex),
+        fractionalPart: allDigits.slice(splitIndex)
+      };
+    }
+  }
+}
+
+// src/num/fixedDecimalToNum.ts
+function fixedDecimalToNum(value) {
+  return Number(fixedDecimalToStr(value));
+}
+
+// src/num/fixedDecimalToStr.ts
+function fixedDecimalToStr(value) {
+  const signSymbol = value.sign < 0 ? "-" : "";
+  const allDigitsString = value.digitsInteger.toString();
+  if (value.scale === 0) {
+    return signSymbol + allDigitsString;
+  }
+  const padZeros = value.scale - allDigitsString.length;
+  if (padZeros >= 0) {
+    return signSymbol + "0." + "0".repeat(padZeros) + allDigitsString;
+  }
+  const integerBoundary = allDigitsString.length - value.scale;
+  const integerText = allDigitsString.slice(0, integerBoundary);
+  const fractionalText = allDigitsString.slice(integerBoundary);
+  return signSymbol + integerText + "." + fractionalText;
+}
+
+// src/num/formatToNum.ts
+function formatToNum(value, round = 1) {
+  return fixedDecimalToNum(round > 1 ? roundFixedDecimal(parseToFixedDecimal(value), round, "half-up") : parseToFixedDecimal(value));
+}
+
+// src/num/normalizeToDecimalComponents.ts
+function normalizeToDecimalComponents(input) {
+  if (typeof input === "bigint") {
+    const sign = input < 0n ? -1 : 1;
+    const absoluteValue = (input < 0n ? -input : input).toString();
+    return {
+      sign,
+      integerPart: absoluteValue,
+      fractionalPart: ""
+    };
+  }
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) {
+      throw new Error("Input number is not finite.");
+    }
+    const sign = input < 0 ? -1 : 1;
+    const absoluteValue = Math.abs(input);
+    const exponentialForm = absoluteValue.toExponential(30);
+    return convertExponentialToParts(sign, exponentialForm);
+  }
+  if (typeof input === "string") {
+    let processed = input.trim().replace(",", ".");
+    if (!processed) {
+      throw new Error("Input string is empty.");
+    }
+    let sign = 1;
+    if (processed.startsWith("+") || processed.startsWith("-")) {
+      sign = processed.startsWith("-") ? -1 : 1;
+      processed = processed.slice(1);
+    }
+    if (/^[0-9]*\.?[0-9]*(e[+\-]?[0-9]+)?$/i.test(processed)) {
+      if (/e/i.test(processed)) {
+        return convertExponentialToParts(sign, processed);
+      }
+      const [integerPart = "0", fractionalPart = ""] = processed.split(".");
+      return {
+        sign,
+        integerPart,
+        fractionalPart
+      };
+    }
+    throw new Error("Invalid numeric string.");
+  }
+  throw new Error("Unsupported input type.");
+}
+
+// src/num/parseToFixedDecimal.ts
+function parseToFixedDecimal(input) {
+  const {
+    sign,
+    integerPart,
+    fractionalPart
+  } = normalizeToDecimalComponents(input);
+  const integerDigits = integerPart.replace(/^0+/, "") || "0";
+  const fractionalDigits = fractionalPart.replace(/0+$/, "");
+  const combinedDigits = integerDigits + fractionalDigits || "0";
+  return {
+    sign,
+    digitsInteger: BigInt(combinedDigits),
+    scale: fractionalDigits.length
+  };
+}
+
+// src/num/roundFixedDecimal.ts
+function roundFixedDecimal(source, decimalPlaces, roundMode = "half-up") {
+  const targetPrecision = Math.max(0, Math.trunc(decimalPlaces));
+  if (source.scale <= targetPrecision) {
+    return { ...source };
+  }
+  const digitsToRemove = source.scale - targetPrecision;
+  const divisionFactor = 10n ** BigInt(digitsToRemove);
+  const integerPart = source.digitsInteger / divisionFactor;
+  const remainder = source.digitsInteger % divisionFactor;
+  if (roundMode === "trunc" || remainder === 0n) {
+    return {
+      sign: source.sign,
+      digitsInteger: integerPart,
+      scale: targetPrecision
+    };
+  }
+  const halfThreshold = divisionFactor / 2n;
+  const shouldRoundUp = remainder >= halfThreshold;
+  const roundedValue = shouldRoundUp ? integerPart + 1n : integerPart;
+  return {
+    sign: source.sign,
+    digitsInteger: roundedValue,
+    scale: targetPrecision
+  };
+}
+
+// src/str/formatToLowerCase.ts
+function formatToLowerCase(value) {
+  if (!isStr(value)) {
+    return "";
+  }
+  const trimmed = formatToTrim(value);
+  return isStrFilled(trimmed) ? trimmed.toLowerCase() : "";
+}
+
+// src/str/formatToNull.ts
+function formatToNull(value) {
+  return isStr(value) && formatToTrim(value) === "" || value === void 0 ? null : value;
+}
+
+// src/str/formatToPhone.ts
+function formatToPhone(value, defaultCountry = "+7") {
+  if (!isStr(value)) {
+    return null;
+  }
+  let phone = formatToTrim(value).replace(/[\s\-().]/g, "");
+  if (/^00\d{8,15}$/.test(phone)) {
+    phone = "+" + phone.slice(2);
+  } else if (/^\d{10}$/.test(phone)) {
+    phone = defaultCountry + phone;
+  } else if (/^\d{9,15}$/.test(phone) && !phone.startsWith("0")) {
+    phone = "+" + phone;
+  }
+  return /^\+\d{10,15}$/.test(phone) ? phone : null;
+}
+
+// src/str/formatToTrim.ts
+function formatToTrim(value) {
+  return String(isStr(value) ? value.trim().normalize("NFKC").replace(/[\u200B-\u200D\uFEFF]/g, "") : "");
+}
+
+// src/str/formatToUndefined.ts
+function formatToUndefined2(value) {
+  return isStr(value) && formatToTrim(value) === "" || value === null ? void 0 : value;
+}
+
+// src/units/toGB.ts
+var KB = 1024;
+var MB = KB * 1024;
+var GB = MB * 1024;
+var TB = GB * 1024;
+var PB = TB * 1024;
+function toGB(value, unit = "") {
+  const v = formatToNum(value);
+  if (!isNum(v)) {
+    throw new Error(`toGB: value "${value}" is not numeric`);
+  }
+  const u = String(unit).trim().toLowerCase().replace(/\s+/g, "");
+  const c = u ? u[0] : "g";
+  let out;
+  switch (c) {
+    case "b":
+      out = v / GB;
+      break;
+    case "k":
+      out = v / MB;
+      break;
+    case "m":
+      out = v / GB;
+      break;
+    case "g":
+      out = v;
+      break;
+    case "t":
+      out = v * (TB / GB);
+      break;
+    case "p":
+      out = v * (PB / GB);
+      break;
+    default:
+      out = v;
+      break;
+  }
+  if (!isNum(out)) {
+    throw new Error(`toGB: result is not finite (value="${value}", unit="${unit}")`);
+  }
+  return Object.is(out, -0) ? 0 : out;
+}
+
+// src/units/normalizeUnit.ts
+function normalizeUnit(u) {
+  return String(u).trim().toLowerCase().replace(/\s+/g, "").replace(/(?:\/?s|hash(?:es)?)$/i, "");
+}
+
+// src/units/toGH.ts
+var FACTOR = {
+  h: 1e-9,
+  k: 1e-6,
+  m: 1e-3,
+  g: 1,
+  t: 1e3,
+  p: 1e6,
+  e: 1e9
+};
+function toGH(value, unit = "") {
+  const v = formatToNum(value);
+  if (!isNum(v)) {
+    return 0;
+  }
+  const u = normalizeUnit(unit);
+  const c = u ? u[0] : "g";
+  const factor = FACTOR[c] ?? 1;
+  const out = v * factor;
+  if (!isNum(out)) {
+    throw new Error(`toGH: result is not finite (value="${v}", unit="${u}")`);
+  }
+  return Object.is(out, -0) ? 0 : out;
+}
+
+// src/units/toH.ts
+var FACTOR_H = {
+  h: 1,
+  k: 1e3,
+  m: 1e6,
+  g: 1e9,
+  t: 1e12,
+  p: 1e15,
+  e: 1e18
+};
+function toH(value, unit = "") {
+  const v = formatToNum(value);
+  if (!isNum(v)) {
+    return 0;
+  }
+  const u = normalizeUnit(unit);
+  const c = u ? u[0] : "h";
+  const factor = FACTOR_H[c] ?? 1;
+  const out = v * factor;
+  if (!isNum(out)) {
+    throw new Error(`toH: result is not finite (value="${v}", unit="${u}")`);
+  }
+  return Object.is(out, -0) ? 0 : out;
+}
+
+// src/url/extractHost.ts
+var HAS_SCHEME = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+function extractHost(value = "") {
+  if (!isStrFilled(value)) {
+    return "";
+  }
+  let v = value.trim();
+  const candidate = HAS_SCHEME.test(v) ? v : `http://${v}`;
+  try {
+    const u = new URL(candidate);
+    let host = u.hostname;
+    return host;
+  } catch {
+    const withoutCreds = v.split("@").pop() || v;
+    const firstSegment = withoutCreds.split(/[/?#]/, 1)[0];
+    const mIPv6 = firstSegment.match(/^\[([^\]]+)\]/);
+    if (mIPv6) {
+      return mIPv6[1];
+    }
+    return firstSegment.split(":", 1)[0] || "";
+  }
+}
+
+export { changeFixedDecimalScale, cidrToRange, convertExponentialToParts, extractHost, fixedDecimalToNum, fixedDecimalToStr, floorDateToMinutes, formatDateToString, formatStrToFuncArgs, formatToBool, formatToLowerCase, formatToNull, formatToNum, formatToPhone, formatToTrim, formatToUndefined2 as formatToUndefined, ipAddrToNum, isArr, isArrFilled, isBool, isDate, isEmail, isExists, isFunc, isIpAddr, isMacAddr, isNum, isNumFloat, isNumN, isNumNZ, isNumP, isNumPZ, isObj, isObjFilled, isPassword, isPhone, isStr, isStrAscDesc, isStrBool, isStrFilled, isVar, jsonDecode, jsonEncode2 as jsonEncode, normalizeToDecimalComponents, numToIpAddr, parseIPv4, parseStringLike, parseToFixedDecimal, partsToSeconds, rangeIPv4, rangeIPv4ToArr2 as rangeIPv4ToArr, roundFixedDecimal, secondsToParts, splitArrToPortions, toGB, toGH, toH, toIPv4, tryParseJSON, wait };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map