@mionjs/type-formats 0.8.0-alpha.0

package/.dist/esm/src/type-formats-pure-fns.js

@@ -0,0 +1,390 @@
+import { registerPureFnFactory } from "@mionjs/core";
+const cpf_isDateString = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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
+];
+export {
+  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
+};
+//# sourceMappingURL=type-formats-pure-fns.js.map

package/.dist/esm/src/type-formats-pure-fns.js.map

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

package/.dist/esm/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/esm/src/utils.js

@@ -0,0 +1,14 @@
+import { isFormatParamMeta } from "@mionjs/run-types";
+function paramVal(p) {
+  return 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!&/"'];
+export {
+  paramVal,
+  regexpEscape
+};
+//# sourceMappingURL=utils.js.map

package/.dist/esm/src/utils.js.map

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

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

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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90-dark.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png">
+    <img alt='mion, a mikro kit for Typescript Serverless APIs' src='https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png'>
+  </picture>
+</p>
+<p align="center">
+  <strong>mion standard middleFns and routes.
+  </strong>
+</p>
+<p align=center>
+  <img src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+  <img src="https://img.shields.io/badge/license-MIT-97ca00.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+</p>
+
+# `@mionjs/type-formats`
+
+`@mionjs/type-formats` provides runtype functionality such as validation and serialization based on TypeScript types. Unlike libraries like Zod or AJV-formats, which use JavaScript to declare schemas, `@mionjs/type-formats` directly leverages TypeScript types and extracts information at compile time to generate validation and serialization functions.
+
+You can find examples of how to use these formats in the various spec files under the `string` directory.
+
+> **⚡ Fast**:  
+> The validation and serialization functions generated by `@mionjs/type-formats` are JIT (Just-In-Time) compiled, ensuring they are highly optimized for performance. This makes them suitable for use in high-throughput applications where efficiency is critical.
+
+## Available Formats
+
+Below is a list of available formats parsed from the spec files:
+
+### String Formats
+
+- **Base String Format**
+  - `StringFormat`: The base format for all string-related validations and transformations. It provides a set of customizable parameters that can be reused to create any custom string format. Below are the available parameters:
+    - **Validators**:
+      - `maxLength`: Maximum length of the string.
+      - `minLength`: Minimum length of the string.
+      - `length`: Exact length of the string.
+      - `allowedChars`: A string containing characters allowed in the string.
+      - `disallowedChars`: A string containing characters not allowed in the string.
+      - `allowedValues`: An array of allowed string values.
+      - `disallowedValues`: An array of disallowed string values.
+      - `pattern`: A regular expression pattern with an optional message and sample values.
+
+    - **Transformers**:
+      - `lowercase`: Converts the string to lowercase.
+      - `uppercase`: Converts the string to uppercase.
+      - `capitalize`: Capitalizes the first letter of the string.
+      - `trim`: Removes whitespace from both ends of the string.
+      - `replace`: Replaces the first occurrence of a substring with another value.
+      - `replaceAll`: Replaces all occurrences of a substring with another value.
+
+- **UUID Formats**
+  - `UUID_V4`: Validates UUID version 4.
+  - `UUID_V7`: Validates UUID version 7.
+
+- **Time Formats**
+  - `TimeString`: Supports formats like `ISO`, `HH:mm:ss[.mmm]TZ`, `HH:mm:ss`, `HH:mm`, `mm:ss`, `HH`, `mm`, `ss`.
+
+- **Date Formats**
+  - `DateString`: Supports formats like `ISO`, `YYYY-MM-DD`, `DD-MM-YYYY`, `MM-DD-YYYY`, `MM-DD`, `DD-MM`, `YYYY-MM`.
+
+- **DateTime Formats**
+  - `DateTimeString`: Combines date and time formats in a customizable way. Most common format is ISO, i.e., `YYYY-MM-DDTHH:mm:ssTZ`.
+
+- **String Validation Formats**
+  - `AlphaString`: Validates strings containing only alphabetic characters.
+  - `AlphaNumericString`: Validates strings containing only alphanumeric characters.
+  - `NumericString`: Validates strings containing only numeric characters.
+  - `LowerString`: Validates strings in lowercase.
+  - `UpperString`: Validates strings in uppercase.
+  - `CapitalString`: Validates strings with the first letter capitalized.
+
+- **Domain Formats**
+  - `Domain`: Validates domain names with customizable parameters for subdomains, TLDs, and length.
+
+- **Email Formats**
+  - `Email`: Validates email addresses with customizable parameters for local parts and domains.
+
+- **IP Formats**
+  - `IP`: Validates IP addresses (IPv4, IPv6, or both) with options for localhost and port inclusion.
+
+- **URL Formats**
+  - `URL`: Validates URLs with customizable parameters for protocols, length, and allowed/disallowed characters.
+
+## Example Usage
+
+### Using `DateTimeString` Format with `isType`
+
+The `DateTimeString` format allows you to validate date-time strings with customizable date and time formats. Below is an example of how to use it with the `isType` function:
+
+```typescript
+import {isTypeFn} from '@mionjs/run-types';
+import {DateTimeString} from '@mionjs/type-formats';
+
+// Customizing DateTimeString to include only year, month, and time (HH:mm:ss)
+type CustomDateTimeString = DateTimeString<{date: {format: 'YYYY-MM'}; time: {format: 'HH:mm:ss'}; splitChar: '/'}>;
+
+const isIsoDateTime = await isTypeFn<DateTimeString>();
+
+// Example usage for default ISO DateTimeString
+console.log(await isIsoDateTime('2024-01-01T12:30:45Z')); // true
+console.log(await isIsoDateTime('2024-01-01T12:30:45')); // true
+console.log(await isIsoDateTime('2024-01-01 12:30:45')); // false (missing 'T' separator)
+console.log(await isIsoDateTime('2024-13-01T12:30:45Z')); // false (invalid month 13)
+
+const isCustomDateTime = await isTypeFn<CustomDateTimeString>();
+
+// Example usage for custom DateTimeString
+console.log(isCustomDateTime('2024-01/12:30:45')); // true
+console.log(isCustomDateTime('2024-01T12:30:45')); // false (wrong split char T instead of the custom /)
+console.log(isCustomDateTime('2024-01-01/12:30:45')); // false (day is not allowed)
+console.log(isCustomDateTime('2024-13/12:30:45')); // false (invalid month 13)
+```
+
+This example demonstrates how to validate both default ISO date-time strings and a custom date-time string format.
+
+## Check Out The [Website And Documentation](http://mion.io) 📚
+
+[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/master/assets/public/mion-website-banner.png)](http://mion.io)
+
+---
+
+[MIT LICENSE](../../LICENSE)

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@mionjs/type-formats",
+  "version": "0.8.0-alpha.0",
+  "type": "module",
+  "description": "mion standard middleFns and routes",
+  "keywords": [
+    "typescript",
+    "API",
+    "RPC",
+    "json",
+    "schema",
+    "generate",
+    "server",
+    "serverless",
+    "framework",
+    "node",
+    "runtime types"
+  ],
+  "author": "ma jerez",
+  "homepage": "https://mion.io/",
+  "license": "MIT",
+  "browser": {},
+  "exports": {
+    "./NumberFormats": {
+      "source": "./NumberFormats.ts",
+      "types": "./.dist/esm/NumberFormats.d.ts",
+      "require": "./.dist/cjs/NumberFormats.cjs",
+      "default": "./.dist/esm/NumberFormats.js"
+    },
+    "./StringFormats": {
+      "source": "./StringFormats.ts",
+      "types": "./.dist/esm/StringFormats.d.ts",
+      "require": "./.dist/cjs/StringFormats.cjs",
+      "default": "./.dist/esm/StringFormats.js"
+    },
+    "./BigintFormats": {
+      "source": "./BigintFormats.ts",
+      "types": "./.dist/esm/BigintFormats.d.ts",
+      "require": "./.dist/cjs/BigintFormats.cjs",
+      "default": "./.dist/esm/BigintFormats.js"
+    },
+    "./constants": {
+      "source": "./constants.ts",
+      "types": "./.dist/esm/src/constants.d.ts",
+      "require": "./.dist/cjs/src/constants.cjs",
+      "default": "./.dist/esm/src/constants.js"
+    }
+  },
+  "directories": {
+    "lib": ".dist"
+  },
+  "files": [
+    ".dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MionKit/mion.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "dev": "vite build --watch",
+    "dev:test": "vitest watch",
+    "lint": "npx eslint src",
+    "format": "prettier --write src/**/*.ts",
+    "build": "vite build",
+    "clean": "rimraf .dist & rimraf .coverage",
+    "fresh-start": "npm run clean && rimraf node_modules"
+  },
+  "bugs": {
+    "url": "https://github.com/MionKit/mion/issues"
+  },
+  "dependencies": {
+    "@mionjs/core": "^0.8.0-alpha.0",
+    "@mionjs/run-types": "^0.8.0-alpha.0"
+  },
+  "gitHead": "5d2ec524ba39d040338ce8946d8edf78aa7291a3"
+}