@mionjs/type-formats 0.8.0-alpha.0

package/.dist/cjs/src/type-formats-pure-fns.cjs

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const cpf_isDateString = core.registerPureFnFactory("mionFormats", "isDateString", function() {
+  return function is_date_string(year, month, day) {
+    let y = void 0;
+    if (year) {
+      if (year.length !== 4)
+        return false;
+      y = Number(year);
+      if (isNaN(y))
+        return false;
+      if (y < 0 || y > 9999)
+        return false;
+    }
+    if (month.length !== 2)
+      return false;
+    const m = Number(month);
+    if (isNaN(m))
+      return false;
+    if (m < 1 || m > 12)
+      return false;
+    if (day) {
+      if (day.length !== 2)
+        return false;
+      const d = Number(day);
+      if (isNaN(d))
+        return false;
+      if (d < 1 || d > 31)
+        return false;
+      if (m === 2) {
+        if (d > 29)
+          return false;
+        if (y && d === 29 && !(y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0)))
+          return false;
+      } else if ((m === 4 || m === 6 || m === 9 || m === 11) && d > 30) {
+        return false;
+      }
+    }
+    return true;
+  };
+}, { bodyHash: "1_oB_gADdf9PX4", paramNames: [], code: "return function is_date_string(year, month, day) {\n    let y = void 0;\n    if (year) {\n      if (year.length !== 4) return false;\n      y = Number(year);\n      if (isNaN(y)) return false;\n      if (y < 0 || y > 9999) return false;\n    }\n    if (month.length !== 2) return false;\n    const m = Number(month);\n    if (isNaN(m)) return false;\n    if (m < 1 || m > 12) return false;\n    if (day) {\n      if (day.length !== 2) return false;\n      const d = Number(day);\n      if (isNaN(d)) return false;\n      if (d < 1 || d > 31) return false;\n      if (m === 2) {\n        if (d > 29) return false;\n        if (y && d === 29 && !(y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0))) return false;\n      } else if ((m === 4 || m === 6 || m === 9 || m === 11) && d > 30) {\n        return false;\n      }\n    }\n    return true;\n  };" });
+const cpf_isDateString_YMD = core.registerPureFnFactory("mionFormats", "isDateString_YMD", function(jUtil) {
+  const isDate = jUtil.getPureFn("mionFormats", "isDateString");
+  return function is_date(value) {
+    const parts = value.split("-");
+    return parts.length === 3 && isDate(parts[0], parts[1], parts[2]);
+  };
+}, { bodyHash: "TgdYN25ps-eNtS", paramNames: ["jUtil"], code: 'const isDate = jUtil.getPureFn("mionFormats", "isDateString");\n  return function is_date(value) {\n    const parts = value.split("-");\n    return parts.length === 3 && isDate(parts[0], parts[1], parts[2]);\n  };' });
+const cpf_isDateString_DMY = core.registerPureFnFactory("mionFormats", "isDateString_DMY", function(jUtil) {
+  const isDate = jUtil.getPureFn("mionFormats", "isDateString");
+  return function is_date(value) {
+    const parts = value.split("-");
+    return parts.length === 3 && isDate(parts[2], parts[1], parts[0]);
+  };
+}, { bodyHash: "aVDMyOqrsrbcbW", paramNames: ["jUtil"], code: 'const isDate = jUtil.getPureFn("mionFormats", "isDateString");\n  return function is_date(value) {\n    const parts = value.split("-");\n    return parts.length === 3 && isDate(parts[2], parts[1], parts[0]);\n  };' });
+const cpf_isDateString_MDY = core.registerPureFnFactory("mionFormats", "isDateString_MDY", function(jUtil) {
+  const isDate = jUtil.getPureFn("mionFormats", "isDateString");
+  return function is_date(value) {
+    const parts = value.split("-");
+    return parts.length === 3 && isDate(parts[2], parts[0], parts[1]);
+  };
+}, { bodyHash: "iM5EqlmgeDmVjF", paramNames: ["jUtil"], code: 'const isDate = jUtil.getPureFn("mionFormats", "isDateString");\n  return function is_date(value) {\n    const parts = value.split("-");\n    return parts.length === 3 && isDate(parts[2], parts[0], parts[1]);\n  };' });
+const cpf_isDateString_YM = core.registerPureFnFactory("mionFormats", "isDateString_YM", function(jUtil) {
+  const isDate = jUtil.getPureFn("mionFormats", "isDateString");
+  return function is_date(value) {
+    const parts = value.split("-");
+    return parts.length === 2 && isDate(parts[0], parts[1]);
+  };
+}, { bodyHash: "aYQTJv_F4JU3nI", paramNames: ["jUtil"], code: 'const isDate = jUtil.getPureFn("mionFormats", "isDateString");\n  return function is_date(value) {\n    const parts = value.split("-");\n    return parts.length === 2 && isDate(parts[0], parts[1]);\n  };' });
+const cpf_isDateString_MD = core.registerPureFnFactory("mionFormats", "isDateString_MD", function(jUtil) {
+  const isDate = jUtil.getPureFn("mionFormats", "isDateString");
+  return function is_date(value) {
+    const parts = value.split("-");
+    return parts.length === 2 && isDate(void 0, parts[0], parts[1]);
+  };
+}, { bodyHash: "NVGldNTml6x6cv", paramNames: ["jUtil"], code: 'const isDate = jUtil.getPureFn("mionFormats", "isDateString");\n  return function is_date(value) {\n    const parts = value.split("-");\n    return parts.length === 2 && isDate(void 0, parts[0], parts[1]);\n  };' });
+const cpf_isDateString_DM = core.registerPureFnFactory("mionFormats", "isDateString_DM", function(jUtil) {
+  const isDate = jUtil.getPureFn("mionFormats", "isDateString");
+  return function is_date(value) {
+    const parts = value.split("-");
+    return parts.length === 2 && isDate(void 0, parts[1], parts[0]);
+  };
+}, { bodyHash: "ItACHY5Jvp_3sG", paramNames: ["jUtil"], code: 'const isDate = jUtil.getPureFn("mionFormats", "isDateString");\n  return function is_date(value) {\n    const parts = value.split("-");\n    return parts.length === 2 && isDate(void 0, parts[1], parts[0]);\n  };' });
+const dateFunctions = [
+  cpf_isDateString,
+  cpf_isDateString_YMD,
+  cpf_isDateString_DMY,
+  cpf_isDateString_MDY,
+  cpf_isDateString_YM,
+  cpf_isDateString_MD,
+  cpf_isDateString_DM
+];
+const cpf_isTimeZone = core.registerPureFnFactory("mionFormats", "isTimeZone", function(jUtil) {
+  const isH = jUtil.getPureFn("mionFormats", "isHours");
+  const isM = jUtil.getPureFn("mionFormats", "isMinutes");
+  return function is_tz(timeZone) {
+    const isZ = timeZone === "Z" || timeZone === "z";
+    if (isZ)
+      return true;
+    const tzParts = timeZone.split(":");
+    if (tzParts.length !== 2)
+      return false;
+    const hours = tzParts[0];
+    const minutes = tzParts[1];
+    return isH(hours) && isM(minutes);
+  };
+}, { bodyHash: "0Zcw0D7iktjrgz", paramNames: ["jUtil"], code: 'const isH = jUtil.getPureFn("mionFormats", "isHours");\n  const isM = jUtil.getPureFn("mionFormats", "isMinutes");\n  return function is_tz(timeZone) {\n    const isZ = timeZone === "Z" || timeZone === "z";\n    if (isZ) return true;\n    const tzParts = timeZone.split(":");\n    if (tzParts.length !== 2) return false;\n    const hours = tzParts[0];\n    const minutes = tzParts[1];\n    return isH(hours) && isM(minutes);\n  };' });
+const cpf_isHours = core.registerPureFnFactory("mionFormats", "isHours", function() {
+  return function is_h(hours) {
+    if (!hours.length || hours.length > 2)
+      return false;
+    const numberHours = Number(hours);
+    if (isNaN(numberHours))
+      return false;
+    return numberHours >= 0 && numberHours <= 23;
+  };
+}, { bodyHash: "wsGHZIT8eblMfW", paramNames: [], code: "return function is_h(hours) {\n    if (!hours.length || hours.length > 2) return false;\n    const numberHours = Number(hours);\n    if (isNaN(numberHours)) return false;\n    return numberHours >= 0 && numberHours <= 23;\n  };" });
+const cpf_isMinutes = core.registerPureFnFactory("mionFormats", "isMinutes", function() {
+  return function is_m(mins) {
+    if (!mins.length || mins.length > 2)
+      return false;
+    const numberMinutes = Number(mins);
+    if (isNaN(numberMinutes))
+      return false;
+    return numberMinutes >= 0 && numberMinutes <= 59;
+  };
+}, { bodyHash: "KEMDuHWSc4_Cv1", paramNames: [], code: "return function is_m(mins) {\n    if (!mins.length || mins.length > 2) return false;\n    const numberMinutes = Number(mins);\n    if (isNaN(numberMinutes)) return false;\n    return numberMinutes >= 0 && numberMinutes <= 59;\n  };" });
+const cpf_isSeconds = core.registerPureFnFactory("mionFormats", "isSeconds", function() {
+  return function is_s(secs) {
+    if (!secs.length || secs.length > 2)
+      return false;
+    const numberSeconds = Number(secs);
+    if (isNaN(numberSeconds))
+      return false;
+    return numberSeconds >= 0 && numberSeconds <= 59;
+  };
+}, { bodyHash: "nq28WUDHB__8hY", paramNames: [], code: "return function is_s(secs) {\n    if (!secs.length || secs.length > 2) return false;\n    const numberSeconds = Number(secs);\n    if (isNaN(numberSeconds)) return false;\n    return numberSeconds >= 0 && numberSeconds <= 59;\n  };" });
+const cpf_isSecondsWithMs = core.registerPureFnFactory("mionFormats", "isSecondsWithMs", function(jUtil) {
+  const isS = jUtil.getPureFn("mionFormats", "isSeconds");
+  return function is_s_ms(secsAnsMls) {
+    const parts = secsAnsMls.split(".");
+    if (parts.length > 2)
+      return false;
+    const secs = parts[0];
+    if (!isS(secs))
+      return false;
+    const mls = parts[1];
+    if (mls) {
+      if (mls.length !== 3)
+        return false;
+      const millisNumber = Number(mls);
+      if (isNaN(millisNumber))
+        return false;
+      if (millisNumber < 0 || millisNumber > 999)
+        return false;
+    }
+    return true;
+  };
+}, { bodyHash: "w-3AxO5Z-3h_a6", paramNames: ["jUtil"], code: 'const isS = jUtil.getPureFn("mionFormats", "isSeconds");\n  return function is_s_ms(secsAnsMls) {\n    const parts = secsAnsMls.split(".");\n    if (parts.length > 2) return false;\n    const secs = parts[0];\n    if (!isS(secs)) return false;\n    const mls = parts[1];\n    if (mls) {\n      if (mls.length !== 3) return false;\n      const millisNumber = Number(mls);\n      if (isNaN(millisNumber)) return false;\n      if (millisNumber < 0 || millisNumber > 999) return false;\n    }\n    return true;\n  };' });
+const cpf_isTimeString_ISO_TZ = core.registerPureFnFactory("mionFormats", "isTimeString_ISO_TZ", function(jUtil) {
+  const isTWms = jUtil.getPureFn("mionFormats", "isTimeString_ISO");
+  const isTZ = jUtil.getPureFn("mionFormats", "isTimeZone");
+  return function is_iso_time(value) {
+    const isZ = value.endsWith("Z") || value.endsWith("z");
+    const isPositiveTZ = isZ || value.indexOf("+") !== -1;
+    const isNegativeTZ = isZ || value.indexOf("-") !== -1;
+    if (!isZ && !isPositiveTZ && !isNegativeTZ)
+      return false;
+    const timeAndTz = isZ ? [value.substring(0, value.length - 1), "Z"] : value.split(isPositiveTZ ? "+" : "-");
+    if (timeAndTz.length !== 2)
+      return false;
+    const time = timeAndTz[0];
+    const tz = timeAndTz[1];
+    return isTWms(time) && isTZ(tz);
+  };
+}, { bodyHash: "NCB_K_7BF-8PZQ", paramNames: ["jUtil"], code: 'const isTWms = jUtil.getPureFn("mionFormats", "isTimeString_ISO");\n  const isTZ = jUtil.getPureFn("mionFormats", "isTimeZone");\n  return function is_iso_time(value) {\n    const isZ = value.endsWith("Z") || value.endsWith("z");\n    const isPositiveTZ = isZ || value.indexOf("+") !== -1;\n    const isNegativeTZ = isZ || value.indexOf("-") !== -1;\n    if (!isZ && !isPositiveTZ && !isNegativeTZ) return false;\n    const timeAndTz = isZ ? [value.substring(0, value.length - 1), "Z"] : value.split(isPositiveTZ ? "+" : "-");\n    if (timeAndTz.length !== 2) return false;\n    const time = timeAndTz[0];\n    const tz = timeAndTz[1];\n    return isTWms(time) && isTZ(tz);\n  };' });
+const cpf_isTimeString_ISO = core.registerPureFnFactory("mionFormats", "isTimeString_ISO", function(jUtil) {
+  const isH = jUtil.getPureFn("mionFormats", "isHours");
+  const isM = jUtil.getPureFn("mionFormats", "isMinutes");
+  const isSWithMls = jUtil.getPureFn("mionFormats", "isSecondsWithMs");
+  return function is_iso_time(value) {
+    const parts = value.split(":");
+    return parts.length === 3 && isH(parts[0]) && isM(parts[1]) && isSWithMls(parts[2]);
+  };
+}, { bodyHash: "joUIF3KmQA7Aws", paramNames: ["jUtil"], code: 'const isH = jUtil.getPureFn("mionFormats", "isHours");\n  const isM = jUtil.getPureFn("mionFormats", "isMinutes");\n  const isSWithMls = jUtil.getPureFn("mionFormats", "isSecondsWithMs");\n  return function is_iso_time(value) {\n    const parts = value.split(":");\n    return parts.length === 3 && isH(parts[0]) && isM(parts[1]) && isSWithMls(parts[2]);\n  };' });
+const cpf_isTimeString_HHmmss = core.registerPureFnFactory("mionFormats", "isTimeString_HHmmss", function(jUtil) {
+  const isH = jUtil.getPureFn("mionFormats", "isHours");
+  const isM = jUtil.getPureFn("mionFormats", "isMinutes");
+  const isS = jUtil.getPureFn("mionFormats", "isSeconds");
+  return function is_iso_time(value) {
+    const parts = value.split(":");
+    return parts.length === 3 && isH(parts[0]) && isM(parts[1]) && isS(parts[2]);
+  };
+}, { bodyHash: "QU-R606PNQuAQE", paramNames: ["jUtil"], code: 'const isH = jUtil.getPureFn("mionFormats", "isHours");\n  const isM = jUtil.getPureFn("mionFormats", "isMinutes");\n  const isS = jUtil.getPureFn("mionFormats", "isSeconds");\n  return function is_iso_time(value) {\n    const parts = value.split(":");\n    return parts.length === 3 && isH(parts[0]) && isM(parts[1]) && isS(parts[2]);\n  };' });
+const cpf_isTimeString_HHmm = core.registerPureFnFactory("mionFormats", "isTimeString_HHmm", function(jUtil) {
+  const isH = jUtil.getPureFn("mionFormats", "isHours");
+  const isM = jUtil.getPureFn("mionFormats", "isMinutes");
+  return function is_iso_time(value) {
+    const parts = value.split(":");
+    return parts.length === 2 && isH(parts[0]) && isM(parts[1]);
+  };
+}, { bodyHash: "wK8lBvI2O4XQ09", paramNames: ["jUtil"], code: 'const isH = jUtil.getPureFn("mionFormats", "isHours");\n  const isM = jUtil.getPureFn("mionFormats", "isMinutes");\n  return function is_iso_time(value) {\n    const parts = value.split(":");\n    return parts.length === 2 && isH(parts[0]) && isM(parts[1]);\n  };' });
+const cpf_isTimeString_mmss = core.registerPureFnFactory("mionFormats", "isTimeString_mmss", function(jUtil) {
+  const isM = jUtil.getPureFn("mionFormats", "isMinutes");
+  const isS = jUtil.getPureFn("mionFormats", "isSeconds");
+  return function is_iso_time(value) {
+    const parts = value.split(":");
+    return parts.length === 2 && isM(parts[0]) && isS(parts[1]);
+  };
+}, { bodyHash: "HBjntCm7aZu5JG", paramNames: ["jUtil"], code: 'const isM = jUtil.getPureFn("mionFormats", "isMinutes");\n  const isS = jUtil.getPureFn("mionFormats", "isSeconds");\n  return function is_iso_time(value) {\n    const parts = value.split(":");\n    return parts.length === 2 && isM(parts[0]) && isS(parts[1]);\n  };' });
+const pureTimeFns = [cpf_isTimeZone, cpf_isHours, cpf_isMinutes, cpf_isSeconds, cpf_isSecondsWithMs];
+const timeFunctions = [
+  cpf_isTimeString_ISO_TZ,
+  cpf_isTimeString_ISO,
+  cpf_isTimeString_HHmmss,
+  cpf_isTimeString_HHmm,
+  cpf_isTimeString_mmss
+];
+const cpf_isUUID = core.registerPureFnFactory("mionFormats", "isUUID", function() {
+  return function is_uuid(value, p) {
+    if (value.length !== 36)
+      return false;
+    for (let i = 0; i < 36; i++) {
+      if (i === 8 || i === 13 || i === 18 || i === 23) {
+        if (value[i] !== "-")
+          return false;
+      } else if (i === 14) {
+        if (value[i] !== p.version)
+          return false;
+      } else {
+        const charCode = value.charCodeAt(i);
+        const is09 = charCode >= 48 && charCode <= 57;
+        const isaf = charCode >= 97 && charCode <= 102;
+        const isAF = charCode >= 65 && charCode <= 70;
+        if (!(is09 || isaf || isAF))
+          return false;
+      }
+    }
+    return true;
+  };
+}, { bodyHash: "32EsOFrtBtCSbQ", paramNames: [], code: 'return function is_uuid(value, p) {\n    if (value.length !== 36) return false;\n    for (let i = 0; i < 36; i++) {\n      if (i === 8 || i === 13 || i === 18 || i === 23) {\n        if (value[i] !== "-") return false;\n      } else if (i === 14) {\n        if (value[i] !== p.version) return false;\n      } else {\n        const charCode = value.charCodeAt(i);\n        const is09 = charCode >= 48 && charCode <= 57;\n        const isaf = charCode >= 97 && charCode <= 102;\n        const isAF = charCode >= 65 && charCode <= 70;\n        if (!(is09 || isaf || isAF)) return false;\n      }\n    }\n    return true;\n  };' });
+const cpf_isLocalHost = core.registerPureFnFactory("mionFormats", "isLocalHost", function() {
+  const lhr = /^localhost$/i;
+  return function is_local_host(ip, p) {
+    if (p.version === 4)
+      return lhr.test(ip) || ip === "127:0:0:1";
+    if (p.version === 6)
+      return ip === "::1" || ip === "0:0:0:0:0:0:0:1";
+    return lhr.test(ip) || ip === "127:0:0:1" || ip === "::1" || ip === "0:0:0:0:0:0:0:1";
+  };
+}, { bodyHash: "ik5yJC7tT_L6xO", paramNames: [], code: 'const lhr = /^localhost$/i;\n  return function is_local_host(ip, p) {\n    if (p.version === 4) return lhr.test(ip) || ip === "127:0:0:1";\n    if (p.version === 6) return ip === "::1" || ip === "0:0:0:0:0:0:0:1";\n    return lhr.test(ip) || ip === "127:0:0:1" || ip === "::1" || ip === "0:0:0:0:0:0:0:1";\n  };' });
+const cpf_isIPV4 = core.registerPureFnFactory("mionFormats", "isIPV4", function(utl) {
+  const is_Localhost = utl.getPureFn("mionFormats", "isLocalHost");
+  function get_address(ip, p) {
+    if (!p.allowPort)
+      return ip;
+    const parts = ip.split(":");
+    if (parts.length > 2)
+      return false;
+    const [address, portS] = parts;
+    if (!portS)
+      return address;
+    const port = Number(portS);
+    if (isNaN(port) || port < 0 || port > 65535)
+      return false;
+    return address;
+  }
+  return function is_ip_v4(ip, p) {
+    const address = get_address(ip, p);
+    if (address === false)
+      return false;
+    const isLocal = is_Localhost(address, p);
+    if (p.allowLocalHost && isLocal)
+      return true;
+    if (!p.allowLocalHost && isLocal)
+      return false;
+    const sections = address.split(".");
+    if (sections.length !== 4)
+      return false;
+    for (const section of sections) {
+      const num = Number(section);
+      if (isNaN(num) || num < 0 || num > 255)
+        return false;
+    }
+    return true;
+  };
+}, { bodyHash: "DL89ezU80jTaqc", paramNames: ["utl"], code: 'const is_Localhost = utl.getPureFn("mionFormats", "isLocalHost");\n  function get_address(ip, p) {\n    if (!p.allowPort) return ip;\n    const parts = ip.split(":");\n    if (parts.length > 2) return false;\n    const [address, portS] = parts;\n    if (!portS) return address;\n    const port = Number(portS);\n    if (isNaN(port) || port < 0 || port > 65535) return false;\n    return address;\n  }\n  return function is_ip_v4(ip, p) {\n    const address = get_address(ip, p);\n    if (address === false) return false;\n    const isLocal = is_Localhost(address, p);\n    if (p.allowLocalHost && isLocal) return true;\n    if (!p.allowLocalHost && isLocal) return false;\n    const sections = address.split(".");\n    if (sections.length !== 4) return false;\n    for (const section of sections) {\n      const num = Number(section);\n      if (isNaN(num) || num < 0 || num > 255) return false;\n    }\n    return true;\n  };' });
+const cpf_isIPV6 = core.registerPureFnFactory("mionFormats", "isIPV6", function(utl) {
+  const is_Localhost = utl.getPureFn("mionFormats", "isLocalHost");
+  const ipv6PortRegexp = /^\[([^\]]+)\](?::(\d+))?$/;
+  function get_address(ip, p) {
+    if (!p.allowPort)
+      return ip;
+    const match = ip.match(ipv6PortRegexp);
+    if (!match)
+      return false;
+    const address = match[1];
+    const port = match[2];
+    if (!port)
+      return address;
+    const num = Number(port);
+    if (isNaN(num) || num < 0 || num > 65535)
+      return false;
+    return address;
+  }
+  return function is_ip_v6(ip, p) {
+    const address = get_address(ip, p);
+    if (address === false)
+      return false;
+    const isLocal = is_Localhost(address, p);
+    if (p.allowLocalHost && isLocal)
+      return true;
+    if (!p.allowLocalHost && isLocal)
+      return false;
+    const sections = address.split(":");
+    if (sections.length < 3 || sections.length > 8)
+      return false;
+    let doubleColon = 0;
+    for (const section of sections) {
+      if (section.length === 0) {
+        doubleColon++;
+        if (doubleColon > 1)
+          return false;
+        continue;
+      }
+      if (section.length > 4)
+        return false;
+      const num = parseInt(section, 16);
+      if (isNaN(num) || num < 0 || num > 65535)
+        return false;
+    }
+    return true;
+  };
+}, { bodyHash: "SL4Gk3IId9J6aa", paramNames: ["utl"], code: 'const is_Localhost = utl.getPureFn("mionFormats", "isLocalHost");\n  const ipv6PortRegexp = /^\\[([^\\]]+)\\](?::(\\d+))?$/;\n  function get_address(ip, p) {\n    if (!p.allowPort) return ip;\n    const match = ip.match(ipv6PortRegexp);\n    if (!match) return false;\n    const address = match[1];\n    const port = match[2];\n    if (!port) return address;\n    const num = Number(port);\n    if (isNaN(num) || num < 0 || num > 65535) return false;\n    return address;\n  }\n  return function is_ip_v6(ip, p) {\n    const address = get_address(ip, p);\n    if (address === false) return false;\n    const isLocal = is_Localhost(address, p);\n    if (p.allowLocalHost && isLocal) return true;\n    if (!p.allowLocalHost && isLocal) return false;\n    const sections = address.split(":");\n    if (sections.length < 3 || sections.length > 8) return false;\n    let doubleColon = 0;\n    for (const section of sections) {\n      if (section.length === 0) {\n        doubleColon++;\n        if (doubleColon > 1) return false;\n        continue;\n      }\n      if (section.length > 4) return false;\n      const num = parseInt(section, 16);\n      if (isNaN(num) || num < 0 || num > 65535) return false;\n    }\n    return true;\n  };' });
+const cpf_mionGetIPErrors = core.registerPureFnFactory("mionFormats", "mionGetIPErrors", function(utl) {
+  const is_ip_v4 = utl.getPureFn("mionFormats", "isIPV4");
+  const is_ip_v6 = utl.getPureFn("mionFormats", "isIPV6");
+  const noopDeps = {};
+  return function get_ip_errors(ip, p, fPath, fErrs, name = "ip") {
+    if (p.version === 4 && !is_ip_v4(ip, p, noopDeps))
+      return fErrs.push({ name, formatPath: [...fPath, "version"], val: 4 }), fErrs;
+    if (p.version === 6 && !is_ip_v6(ip, p, noopDeps))
+      return fErrs.push({ name, formatPath: [...fPath, "version"], val: 6 }), fErrs;
+    const isIP = is_ip_v4(ip, p, noopDeps) || is_ip_v6(ip, p, noopDeps);
+    if (!isIP)
+      fErrs.push({ name, formatPath: ["version"], val: "any" });
+    return fErrs;
+  };
+}, { bodyHash: "DqM0k2QRxqOTpQ", paramNames: ["utl"], code: 'const is_ip_v4 = utl.getPureFn("mionFormats", "isIPV4");\n  const is_ip_v6 = utl.getPureFn("mionFormats", "isIPV6");\n  const noopDeps = {};\n  return function get_ip_errors(ip, p, fPath, fErrs, name = "ip") {\n    if (p.version === 4 && !is_ip_v4(ip, p, noopDeps))\n      return fErrs.push({ name, formatPath: [...fPath, "version"], val: 4 }), fErrs;\n    if (p.version === 6 && !is_ip_v6(ip, p, noopDeps))\n      return fErrs.push({ name, formatPath: [...fPath, "version"], val: 6 }), fErrs;\n    const isIP = is_ip_v4(ip, p, noopDeps) || is_ip_v6(ip, p, noopDeps);\n    if (!isIP) fErrs.push({ name, formatPath: ["version"], val: "any" });\n    return fErrs;\n  };' });
+const ipFunctions = [cpf_isLocalHost, cpf_isIPV4, cpf_isIPV6, cpf_mionGetIPErrors];
+const mionFormatsPureFunctions = [
+  // Date functions
+  ...dateFunctions,
+  // Time functions
+  ...pureTimeFns,
+  ...timeFunctions,
+  // UUID functions
+  cpf_isUUID,
+  // IP functions
+  ...ipFunctions
+];
+exports.cpf_isDateString = cpf_isDateString;
+exports.cpf_isDateString_DM = cpf_isDateString_DM;
+exports.cpf_isDateString_DMY = cpf_isDateString_DMY;
+exports.cpf_isDateString_MD = cpf_isDateString_MD;
+exports.cpf_isDateString_MDY = cpf_isDateString_MDY;
+exports.cpf_isDateString_YM = cpf_isDateString_YM;
+exports.cpf_isDateString_YMD = cpf_isDateString_YMD;
+exports.cpf_isHours = cpf_isHours;
+exports.cpf_isIPV4 = cpf_isIPV4;
+exports.cpf_isIPV6 = cpf_isIPV6;
+exports.cpf_isLocalHost = cpf_isLocalHost;
+exports.cpf_isMinutes = cpf_isMinutes;
+exports.cpf_isSeconds = cpf_isSeconds;
+exports.cpf_isSecondsWithMs = cpf_isSecondsWithMs;
+exports.cpf_isTimeString_HHmm = cpf_isTimeString_HHmm;
+exports.cpf_isTimeString_HHmmss = cpf_isTimeString_HHmmss;
+exports.cpf_isTimeString_ISO = cpf_isTimeString_ISO;
+exports.cpf_isTimeString_ISO_TZ = cpf_isTimeString_ISO_TZ;
+exports.cpf_isTimeString_mmss = cpf_isTimeString_mmss;
+exports.cpf_isTimeZone = cpf_isTimeZone;
+exports.cpf_isUUID = cpf_isUUID;
+exports.cpf_mionGetIPErrors = cpf_mionGetIPErrors;
+exports.dateFunctions = dateFunctions;
+exports.ipFunctions = ipFunctions;
+exports.mionFormatsPureFunctions = mionFormatsPureFunctions;
+exports.pureTimeFns = pureTimeFns;
+exports.timeFunctions = timeFunctions;
+//# sourceMappingURL=type-formats-pure-fns.cjs.map

package/.dist/cjs/src/type-formats-pure-fns.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-formats-pure-fns.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/cjs/src/type-formats-pure-fns.d.ts

@@ -0,0 +1,27 @@
+export declare const cpf_isDateString: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_YMD: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_DMY: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_MDY: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_YM: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_MD: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_DM: import('@mionjs/core').CompiledPureFunction;
+export declare const dateFunctions: import('@mionjs/core').CompiledPureFunction[];
+export declare const cpf_isTimeZone: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isHours: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isMinutes: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isSeconds: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isSecondsWithMs: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_ISO_TZ: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_ISO: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_HHmmss: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_HHmm: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_mmss: import('@mionjs/core').CompiledPureFunction;
+export declare const pureTimeFns: import('@mionjs/core').CompiledPureFunction[];
+export declare const timeFunctions: import('@mionjs/core').CompiledPureFunction[];
+export declare const cpf_isUUID: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isLocalHost: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isIPV4: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isIPV6: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_mionGetIPErrors: import('@mionjs/core').CompiledPureFunction;
+export declare const ipFunctions: import('@mionjs/core').CompiledPureFunction[];
+export declare const mionFormatsPureFunctions: import('@mionjs/core').CompiledPureFunction[];

package/.dist/cjs/src/utils.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+function paramVal(p) {
+  return runTypes.isFormatParamMeta(p) ? p.val : p;
+}
+paramVal.__type = ["FormatParam", "p", "paramVal", 'P"w!2""/#'];
+function regexpEscape(val) {
+  return val.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+regexpEscape.__type = ["val", "regexpEscape", 'P&2!&/"'];
+exports.paramVal = paramVal;
+exports.regexpEscape = regexpEscape;
+//# sourceMappingURL=utils.cjs.map

package/.dist/cjs/src/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/.dist/cjs/src/utils.d.ts

@@ -0,0 +1,3 @@
+import { FormatParam, FormatParamLiteral } from '@mionjs/core';
+export declare function paramVal<L extends FormatParamLiteral>(p: FormatParam<L>): L;
+export declare function regexpEscape(val: string): string;

package/.dist/cjs/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfig;
+export default _default;

package/.dist/esm/BigintFormats.d.ts

@@ -0,0 +1,2 @@
+export * from './src/bigint/bigIntFormat.runtype.ts';
+export * from './src/bigint/defaultBigNumberFormats.ts';

package/.dist/esm/BigintFormats.js

@@ -0,0 +1,14 @@
+import { BIGINT_RUN_TYPE_FORMATTER, BigIntRunTypeFormat, __ΩFormatBigInt } from "./src/bigint/bigIntFormat.runtype.js";
+import { __ΩFormatBigInt64, __ΩFormatBigNegative, __ΩFormatBigNegativeInt, __ΩFormatBigPositive, __ΩFormatBigPositiveInt, __ΩFormatBigUInt64 } from "./src/bigint/defaultBigNumberFormats.js";
+export {
+  BIGINT_RUN_TYPE_FORMATTER,
+  BigIntRunTypeFormat,
+  __ΩFormatBigInt,
+  __ΩFormatBigInt64,
+  __ΩFormatBigNegative,
+  __ΩFormatBigNegativeInt,
+  __ΩFormatBigPositive,
+  __ΩFormatBigPositiveInt,
+  __ΩFormatBigUInt64
+};
+//# sourceMappingURL=BigintFormats.js.map

package/.dist/esm/BigintFormats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigintFormats.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/.dist/esm/NumberFormats.d.ts

@@ -0,0 +1,2 @@
+export * from './src/number/numberFormat.runtype.ts';
+export * from './src/number/defaultNumberFormats.ts';

package/.dist/esm/NumberFormats.js

@@ -0,0 +1,20 @@
+import { NUMBER_RUN_TYPE_FORMATTER, NumberRunTypeFormat, __ΩFormatNumber } from "./src/number/numberFormat.runtype.js";
+import { __ΩFormatFloat, __ΩFormatInt16, __ΩFormatInt32, __ΩFormatInt8, __ΩFormatInteger, __ΩFormatNegative, __ΩFormatNegativeInt, __ΩFormatPositive, __ΩFormatPositiveInt, __ΩFormatUInt16, __ΩFormatUInt32, __ΩFormatUInt8 } from "./src/number/defaultNumberFormats.js";
+export {
+  NUMBER_RUN_TYPE_FORMATTER,
+  NumberRunTypeFormat,
+  __ΩFormatFloat,
+  __ΩFormatInt16,
+  __ΩFormatInt32,
+  __ΩFormatInt8,
+  __ΩFormatInteger,
+  __ΩFormatNegative,
+  __ΩFormatNegativeInt,
+  __ΩFormatNumber,
+  __ΩFormatPositive,
+  __ΩFormatPositiveInt,
+  __ΩFormatUInt16,
+  __ΩFormatUInt32,
+  __ΩFormatUInt8
+};
+//# sourceMappingURL=NumberFormats.js.map

package/.dist/esm/NumberFormats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NumberFormats.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/.dist/esm/StringFormats.d.ts

@@ -0,0 +1,11 @@
+export * from './src/string/stringFormat.runtype.ts';
+export * from './src/string/date.runtype.ts';
+export * from './src/string/dateTime.runtype.ts';
+export * from './src/string/time.runtype.ts';
+export * from './src/string/email.runtype.ts';
+export * from './src/string/domain.runtype.ts';
+export * from './src/string/url.runtype.ts';
+export * from './src/string/ip.runtype.ts';
+export * from './src/string/uuid.runtype.ts';
+export * from './src/string/defaultStringFormats.runtype.ts';
+export * from './src/type-formats-pure-fns.ts';

package/.dist/esm/StringFormats.js

@@ -0,0 +1,120 @@
+import { cpf_isDateString, cpf_isDateString_DM, cpf_isDateString_DMY, cpf_isDateString_MD, cpf_isDateString_MDY, cpf_isDateString_YM, cpf_isDateString_YMD, cpf_isHours, cpf_isIPV4, cpf_isIPV6, cpf_isLocalHost, cpf_isMinutes, cpf_isSeconds, cpf_isSecondsWithMs, cpf_isTimeString_HHmm, cpf_isTimeString_HHmmss, cpf_isTimeString_ISO, cpf_isTimeString_ISO_TZ, cpf_isTimeString_mmss, cpf_isTimeZone, cpf_isUUID, cpf_mionGetIPErrors, dateFunctions, ipFunctions, mionFormatsPureFunctions, pureTimeFns, timeFunctions } from "./src/type-formats-pure-fns.js";
+import { DATE_RUN_TYPE_FORMATTER, DateStringRunTypeFormat, __ΩDEFAULT_DATE_PARAMS, __ΩFormatStringDate } from "./src/string/date.runtype.js";
+import { DATE_TIME_RUN_TYPE_FORMATTER, DateTimeRunTypeFormat, __ΩDEFAULT_DATE_TIME_PARAMS, __ΩFormatStringDateTime } from "./src/string/dateTime.runtype.js";
+import { TIME_RUN_TYPE_FORMATTER, TimeStringRunTypeFormat, __ΩDEFAULT_TIME_FORMAT_PARAMS, __ΩFormatStringTime, mockMilliseconds, mockTimeZone } from "./src/string/time.runtype.js";
+import { EMAIL_PATTERN, EMAIL_PATTERN_PUNYCODE, EMAIL_RUN_TYPE_FORMATTER, EmailRunTypeFormat, __ΩDEFAULT_EMAIL_PARAMS, __ΩDEFAULT_STRICT_EMAIL_PARAMS, __ΩFormatEmail, __ΩFormatEmailPattern, __ΩFormatEmailPunycode, __ΩFormatEmailStrict } from "./src/string/email.runtype.js";
+import { DOMAIN_ALLOWED_CHARS_PATTERN, DOMAIN_PATTERN, DOMAIN_PATTERN_PUNYCODE, DOMAIN_PATTERN_UNICODE, DOMAIN_RUN_TYPE_FORMATTER, DomainRunTypeFormat, TLD_ALLOWED_CHARS_PATTERN, __ΩDEFAULT_DMM_TLD_PARAMS, __ΩDEFAULT_DOMAIN_PARAMS, __ΩDEFAULT_DOM_NAME_PARAMS, __ΩDEFAULT_STRICT_DOMAIN_PARAMS, __ΩFormatDomain, __ΩFormatDomainStrict } from "./src/string/domain.runtype.js";
+import { URLRunTypeFormat, URL_FILE_REGEXP, URL_HTTP_REGEXP, URL_REGEXP, URL_RUN_TYPE_FORMATTER, __ΩDEFAULT_URL_FILE_PARAMS, __ΩDEFAULT_URL_HTTP_PARAMS, __ΩDEFAULT_URL_PARAMS, __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS, __ΩFormatUrl, __ΩFormatUrlFile, __ΩFormatUrlHttp, __ΩFormatUrlSocialMedia } from "./src/string/url.runtype.js";
+import { IPRunTypeFormat, IP_RUN_TYPE_FORMATTER, __ΩFormatIP, __ΩFormatIPWithPort, __ΩFormatIPv4, __ΩFormatIPv4WithPort, __ΩFormatIPv6, __ΩFormatIPv6WithPort, mockIpV4, mockIpV6 } from "./src/string/ip.runtype.js";
+import { UUIDRunTypeFormat, UUID_RUN_TYPE_FORMATTER, __ΩFormatUUIDv4, __ΩFormatUUIDv7 } from "./src/string/uuid.runtype.js";
+import { ALPHANUMERIC_REGEX, ALPHA_REGEX, NUMERIC_REGEX, __ΩFormatAlpha, __ΩFormatAlphaNumeric, __ΩFormatCapitalize, __ΩFormatLowercase, __ΩFormatNumeric, __ΩFormatUppercase } from "./src/string/defaultStringFormats.runtype.js";
+import { STRING_RUN_TYPE_FORMATTER, StringRunTypeFormat, __ΩFormatString, isPatternParam, patternParamsToStrParams, stringIgnoreProps } from "./src/string/stringFormat.runtype.js";
+export {
+  ALPHANUMERIC_REGEX,
+  ALPHA_REGEX,
+  DATE_RUN_TYPE_FORMATTER,
+  DATE_TIME_RUN_TYPE_FORMATTER,
+  DOMAIN_ALLOWED_CHARS_PATTERN,
+  DOMAIN_PATTERN,
+  DOMAIN_PATTERN_PUNYCODE,
+  DOMAIN_PATTERN_UNICODE,
+  DOMAIN_RUN_TYPE_FORMATTER,
+  DateStringRunTypeFormat,
+  DateTimeRunTypeFormat,
+  DomainRunTypeFormat,
+  EMAIL_PATTERN,
+  EMAIL_PATTERN_PUNYCODE,
+  EMAIL_RUN_TYPE_FORMATTER,
+  EmailRunTypeFormat,
+  IPRunTypeFormat,
+  IP_RUN_TYPE_FORMATTER,
+  NUMERIC_REGEX,
+  STRING_RUN_TYPE_FORMATTER,
+  StringRunTypeFormat,
+  TIME_RUN_TYPE_FORMATTER,
+  TLD_ALLOWED_CHARS_PATTERN,
+  TimeStringRunTypeFormat,
+  URLRunTypeFormat,
+  URL_FILE_REGEXP,
+  URL_HTTP_REGEXP,
+  URL_REGEXP,
+  URL_RUN_TYPE_FORMATTER,
+  UUIDRunTypeFormat,
+  UUID_RUN_TYPE_FORMATTER,
+  __ΩDEFAULT_DATE_PARAMS,
+  __ΩDEFAULT_DATE_TIME_PARAMS,
+  __ΩDEFAULT_DMM_TLD_PARAMS,
+  __ΩDEFAULT_DOMAIN_PARAMS,
+  __ΩDEFAULT_DOM_NAME_PARAMS,
+  __ΩDEFAULT_EMAIL_PARAMS,
+  __ΩDEFAULT_STRICT_DOMAIN_PARAMS,
+  __ΩDEFAULT_STRICT_EMAIL_PARAMS,
+  __ΩDEFAULT_TIME_FORMAT_PARAMS,
+  __ΩDEFAULT_URL_FILE_PARAMS,
+  __ΩDEFAULT_URL_HTTP_PARAMS,
+  __ΩDEFAULT_URL_PARAMS,
+  __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS,
+  __ΩFormatAlpha,
+  __ΩFormatAlphaNumeric,
+  __ΩFormatCapitalize,
+  __ΩFormatDomain,
+  __ΩFormatDomainStrict,
+  __ΩFormatEmail,
+  __ΩFormatEmailPattern,
+  __ΩFormatEmailPunycode,
+  __ΩFormatEmailStrict,
+  __ΩFormatIP,
+  __ΩFormatIPWithPort,
+  __ΩFormatIPv4,
+  __ΩFormatIPv4WithPort,
+  __ΩFormatIPv6,
+  __ΩFormatIPv6WithPort,
+  __ΩFormatLowercase,
+  __ΩFormatNumeric,
+  __ΩFormatString,
+  __ΩFormatStringDate,
+  __ΩFormatStringDateTime,
+  __ΩFormatStringTime,
+  __ΩFormatUUIDv4,
+  __ΩFormatUUIDv7,
+  __ΩFormatUppercase,
+  __ΩFormatUrl,
+  __ΩFormatUrlFile,
+  __ΩFormatUrlHttp,
+  __ΩFormatUrlSocialMedia,
+  cpf_isDateString,
+  cpf_isDateString_DM,
+  cpf_isDateString_DMY,
+  cpf_isDateString_MD,
+  cpf_isDateString_MDY,
+  cpf_isDateString_YM,
+  cpf_isDateString_YMD,
+  cpf_isHours,
+  cpf_isIPV4,
+  cpf_isIPV6,
+  cpf_isLocalHost,
+  cpf_isMinutes,
+  cpf_isSeconds,
+  cpf_isSecondsWithMs,
+  cpf_isTimeString_HHmm,
+  cpf_isTimeString_HHmmss,
+  cpf_isTimeString_ISO,
+  cpf_isTimeString_ISO_TZ,
+  cpf_isTimeString_mmss,
+  cpf_isTimeZone,
+  cpf_isUUID,
+  cpf_mionGetIPErrors,
+  dateFunctions,
+  ipFunctions,
+  isPatternParam,
+  mionFormatsPureFunctions,
+  mockIpV4,
+  mockIpV6,
+  mockMilliseconds,
+  mockTimeZone,
+  patternParamsToStrParams,
+  pureTimeFns,
+  stringIgnoreProps,
+  timeFunctions
+};
+//# sourceMappingURL=StringFormats.js.map

package/.dist/esm/StringFormats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringFormats.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/.dist/esm/constants.d.ts

@@ -0,0 +1 @@
+export { FormatNames, FormatName } from './src/constants.ts';