@mionjs/type-formats 0.8.0-alpha.0

package/.dist/cjs/BigintFormats.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_bigint_bigIntFormat_runtype = require("./src/bigint/bigIntFormat.runtype.cjs");
+const src_bigint_defaultBigNumberFormats = require("./src/bigint/defaultBigNumberFormats.cjs");
+exports.BIGINT_RUN_TYPE_FORMATTER = src_bigint_bigIntFormat_runtype.BIGINT_RUN_TYPE_FORMATTER;
+exports.BigIntRunTypeFormat = src_bigint_bigIntFormat_runtype.BigIntRunTypeFormat;
+exports.__ΩFormatBigInt = src_bigint_bigIntFormat_runtype.__ΩFormatBigInt;
+exports.__ΩFormatBigInt64 = src_bigint_defaultBigNumberFormats.__ΩFormatBigInt64;
+exports.__ΩFormatBigNegative = src_bigint_defaultBigNumberFormats.__ΩFormatBigNegative;
+exports.__ΩFormatBigNegativeInt = src_bigint_defaultBigNumberFormats.__ΩFormatBigNegativeInt;
+exports.__ΩFormatBigPositive = src_bigint_defaultBigNumberFormats.__ΩFormatBigPositive;
+exports.__ΩFormatBigPositiveInt = src_bigint_defaultBigNumberFormats.__ΩFormatBigPositiveInt;
+exports.__ΩFormatBigUInt64 = src_bigint_defaultBigNumberFormats.__ΩFormatBigUInt64;
+//# sourceMappingURL=BigintFormats.cjs.map

package/.dist/cjs/BigintFormats.cjs.map

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

package/.dist/cjs/BigintFormats.d.ts

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

package/.dist/cjs/NumberFormats.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_number_numberFormat_runtype = require("./src/number/numberFormat.runtype.cjs");
+const src_number_defaultNumberFormats = require("./src/number/defaultNumberFormats.cjs");
+exports.NUMBER_RUN_TYPE_FORMATTER = src_number_numberFormat_runtype.NUMBER_RUN_TYPE_FORMATTER;
+exports.NumberRunTypeFormat = src_number_numberFormat_runtype.NumberRunTypeFormat;
+exports.__ΩFormatNumber = src_number_numberFormat_runtype.__ΩFormatNumber;
+exports.__ΩFormatFloat = src_number_defaultNumberFormats.__ΩFormatFloat;
+exports.__ΩFormatInt16 = src_number_defaultNumberFormats.__ΩFormatInt16;
+exports.__ΩFormatInt32 = src_number_defaultNumberFormats.__ΩFormatInt32;
+exports.__ΩFormatInt8 = src_number_defaultNumberFormats.__ΩFormatInt8;
+exports.__ΩFormatInteger = src_number_defaultNumberFormats.__ΩFormatInteger;
+exports.__ΩFormatNegative = src_number_defaultNumberFormats.__ΩFormatNegative;
+exports.__ΩFormatNegativeInt = src_number_defaultNumberFormats.__ΩFormatNegativeInt;
+exports.__ΩFormatPositive = src_number_defaultNumberFormats.__ΩFormatPositive;
+exports.__ΩFormatPositiveInt = src_number_defaultNumberFormats.__ΩFormatPositiveInt;
+exports.__ΩFormatUInt16 = src_number_defaultNumberFormats.__ΩFormatUInt16;
+exports.__ΩFormatUInt32 = src_number_defaultNumberFormats.__ΩFormatUInt32;
+exports.__ΩFormatUInt8 = src_number_defaultNumberFormats.__ΩFormatUInt8;
+//# sourceMappingURL=NumberFormats.cjs.map

package/.dist/cjs/NumberFormats.cjs.map

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

package/.dist/cjs/NumberFormats.d.ts

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

package/.dist/cjs/StringFormats.cjs

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

package/.dist/cjs/StringFormats.cjs.map

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

package/.dist/cjs/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/cjs/constants.d.ts

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

package/.dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/.dist/cjs/src/bigint/bigIntFormat.runtype.cjs

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+const type = require("@deepkit/type");
+const src_utils = require("../utils.cjs");
+const BIGINT64_MIN = -9223372036854775808n;
+const BIGINT64_MAX = 9223372036854775807n;
+const BIGUINT64_MIN = 0n;
+const BIGUINT64_MAX = 18446744073709551615n;
+class BigIntRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "bigintFormat";
+  kind = type.ReflectionKind.bigint;
+  name = BigIntRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const v = comp.vλl;
+    const conditions = [];
+    if (params.max !== void 0) {
+      const maxVal = src_utils.paramVal(params.max);
+      conditions.push(`${v} <= ${maxVal}n`);
+    }
+    if (params.min !== void 0) {
+      const minVal = src_utils.paramVal(params.min);
+      conditions.push(`${v} >= ${minVal}n`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = src_utils.paramVal(params.lt);
+      conditions.push(`${v} < ${ltVal}n`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = src_utils.paramVal(params.gt);
+      conditions.push(`${v} > ${gtVal}n`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = src_utils.paramVal(params.multipleOf);
+      conditions.push(`(${v} % ${multipleOfVal}n === 0n)`);
+    }
+    return { code: conditions.length ? conditions.join(" && ") : "true", type: "E" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const params = this.getParams(rt);
+    const v = comp.vλl;
+    const errFn = this.getCallJitFormatErr(comp, rt, this, false);
+    const conditions = [];
+    if (params.max !== void 0) {
+      const maxVal = src_utils.paramVal(params.max);
+      conditions.push(`if (${v} > ${maxVal}n) ${errFn("max", maxVal)}`);
+    }
+    if (params.min !== void 0) {
+      const minVal = src_utils.paramVal(params.min);
+      conditions.push(`if (${v} < ${minVal}n) ${errFn("min", minVal)}`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = src_utils.paramVal(params.lt);
+      conditions.push(`if (${v} >= ${ltVal}n) ${errFn("lt", ltVal)}`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = src_utils.paramVal(params.gt);
+      conditions.push(`if (${v} <= ${gtVal}n) ${errFn("gt", gtVal)}`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = src_utils.paramVal(params.multipleOf);
+      conditions.push(`if ((${v} % ${multipleOfVal}n !== 0n)) ${errFn("multipleOf", multipleOfVal)}`);
+    }
+    return { code: conditions.join(";"), type: "S" };
+  }
+  // No format transformation needed for bigints
+  emitFormat() {
+    return { code: void 0, type: "S" };
+  }
+  emitToBinary(comp, rt) {
+    const params = this.getParams(rt);
+    const bigintType = getBigIntType(params);
+    if (bigintType.isBigInt64 || bigintType.isBigUInt64) {
+      const sεr = comp.args.sεr;
+      if (bigintType.isBigUInt64) {
+        return { code: `${sεr}.view.setBigUint64(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 8)`, type: "S" };
+      }
+      return { code: `${sεr}.view.setBigInt64(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 8)`, type: "S" };
+    }
+    return { code: void 0, type: "S" };
+  }
+  emitFromBinary(comp, rt) {
+    const params = this.getParams(rt);
+    const bigintType = getBigIntType(params);
+    if (bigintType.isBigInt64 || bigintType.isBigUInt64) {
+      const dεs = comp.args.dεs;
+      if (bigintType.isBigUInt64) {
+        return { code: `${dεs}.view.getBigUint64(${dεs}.index, 1, ${dεs}.index += 8)`, type: "E" };
+      }
+      return { code: `${dεs}.view.getBigInt64(${dεs}.index, 1, ${dεs}.index += 8)`, type: "E" };
+    }
+    return { code: void 0, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    let min = params.min !== void 0 ? src_utils.paramVal(params.min) : -99999n;
+    let max = params.max !== void 0 ? src_utils.paramVal(params.max) : 99999n;
+    if (params.gt !== void 0) {
+      const gtVal = src_utils.paramVal(params.gt);
+      min = gtVal + 1n;
+    }
+    if (params.lt !== void 0) {
+      const ltVal = src_utils.paramVal(params.lt);
+      max = ltVal - 1n;
+    }
+    const minNum = Number(min > BigInt(Number.MIN_SAFE_INTEGER) ? min : BigInt(Number.MIN_SAFE_INTEGER));
+    const maxNum = Number(max < BigInt(Number.MAX_SAFE_INTEGER) ? max : BigInt(Number.MAX_SAFE_INTEGER));
+    let result = BigInt(runTypes.random(minNum, maxNum));
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = src_utils.paramVal(params.multipleOf);
+      const factor = result / multipleOfVal;
+      result = factor * multipleOfVal;
+    }
+    return result;
+  }
+  validateParams(rt, params) {
+    const lowerBoundCount = [params.min, params.gt].filter(Boolean).length;
+    if (lowerBoundCount > 1) {
+      throw new Error(`Cannot specify more than one of min or gt in ${this.printPath(rt)}`);
+    }
+    const upperBoundCount = [params.max, params.lt].filter(Boolean).length;
+    if (upperBoundCount > 1) {
+      throw new Error(`Cannot specify more than one of max or lt in ${this.printPath(rt)}`);
+    }
+    if (params.min && params.max && src_utils.paramVal(params.min) > src_utils.paramVal(params.max)) {
+      throw new Error(`min cannot be greater than max in ${this.printPath(rt)}`);
+    }
+    if (params.gt && params.lt && src_utils.paramVal(params.gt) >= src_utils.paramVal(params.lt)) {
+      throw new Error(`gt cannot be greater than or equal to lt in ${this.printPath(rt)}`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = src_utils.paramVal(params.multipleOf);
+      if (multipleOfVal <= 0) {
+        throw new Error(`multipleOf must be greater than 0 in ${this.printPath(rt)}`);
+      }
+    }
+  }
+}
+function getBigIntType(params) {
+  const min = params.min !== void 0 ? src_utils.paramVal(params.min) : void 0;
+  const max = params.max !== void 0 ? src_utils.paramVal(params.max) : void 0;
+  const isBigInt64 = min !== void 0 && max !== void 0 && min >= BIGINT64_MIN && max <= BIGINT64_MAX;
+  const isBigUInt64 = min !== void 0 && max !== void 0 && min >= BIGUINT64_MIN && max <= BIGUINT64_MAX;
+  return { isBigInt64, isBigUInt64 };
+}
+const BIGINT_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new BigIntRunTypeFormat());
+const __ΩFormatBigInt = ["P", "BrandName", () => runTypes.__ΩTypeFormat, () => BigIntRunTypeFormat.id, "FormatBigInt", 'PMc!!c"*i$e!!e!"o#%w%y'];
+exports.BIGINT_RUN_TYPE_FORMATTER = BIGINT_RUN_TYPE_FORMATTER;
+exports.BigIntRunTypeFormat = BigIntRunTypeFormat;
+exports.__ΩFormatBigInt = __ΩFormatBigInt;
+//# sourceMappingURL=bigIntFormat.runtype.cjs.map

package/.dist/cjs/src/bigint/bigIntFormat.runtype.cjs.map

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

package/.dist/cjs/src/bigint/bigIntFormat.runtype.d.ts

@@ -0,0 +1,21 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, jitBinarySerializerArgs, JitFunctions, BaseFnCompiler, jitBinaryDeserializerArgs, TypeFormat, BaseRunTypeFormat, RunTypeOptions } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { FormatParams_BigInt } from '@mionjs/core';
+type BinarySerializer = BaseFnCompiler<typeof jitBinarySerializerArgs, typeof JitFunctions.toBinary.id>;
+type BinaryDeserializer = BaseFnCompiler<typeof jitBinaryDeserializerArgs, typeof JitFunctions.fromBinary.id>;
+export declare class BigIntRunTypeFormat extends BaseRunTypeFormat<FormatParams_BigInt> {
+    static readonly id: "bigintFormat";
+    readonly kind = ReflectionKind.bigint;
+    readonly name: "bigintFormat";
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    emitFormat(): JitCode;
+    emitToBinary(comp: BinarySerializer, rt: BaseRunType): JitCode;
+    emitFromBinary(comp: BinaryDeserializer, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): bigint;
+    validateParams(rt: BaseRunType, params: FormatParams_BigInt): void;
+}
+export declare const BIGINT_RUN_TYPE_FORMATTER: BigIntRunTypeFormat;
+export type FormatBigInt<P extends Partial<FormatParams_BigInt> = {}, BrandName extends string = never> = TypeFormat<bigint, typeof BigIntRunTypeFormat.id, P, BrandName>;
+export {};
+export declare type __ΩFormatBigInt = any[];

package/.dist/cjs/src/bigint/defaultBigNumberFormats.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_bigint_bigIntFormat_runtype = require("./bigIntFormat.runtype.cjs");
+const __ΩFormatBigPositive = [() => src_bigint_bigIntFormat_runtype.__ΩFormatBigInt, 0n, "min", "FormatBigPositive", 'P."4#Mo!"w$y'];
+const __ΩFormatBigNegative = [() => src_bigint_bigIntFormat_runtype.__ΩFormatBigInt, 0n, "max", "FormatBigNegative", 'P."4#Mo!"w$y'];
+const __ΩFormatBigPositiveInt = [() => src_bigint_bigIntFormat_runtype.__ΩFormatBigInt, 0n, "min", 1n, "multipleOf", "FormatBigPositiveInt", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatBigNegativeInt = [() => src_bigint_bigIntFormat_runtype.__ΩFormatBigInt, 0n, "max", 1n, "multipleOf", "FormatBigNegativeInt", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatBigInt64 = [() => src_bigint_bigIntFormat_runtype.__ΩFormatBigInt, -9223372036854775808n, "min", 9223372036854775807n, "max", "FormatBigInt64", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatBigUInt64 = [() => src_bigint_bigIntFormat_runtype.__ΩFormatBigInt, 0n, "min", 18446744073709551615n, "max", "FormatBigUInt64", 'P."4#.$4%Mo!"w&y'];
+exports.__ΩFormatBigInt64 = __ΩFormatBigInt64;
+exports.__ΩFormatBigNegative = __ΩFormatBigNegative;
+exports.__ΩFormatBigNegativeInt = __ΩFormatBigNegativeInt;
+exports.__ΩFormatBigPositive = __ΩFormatBigPositive;
+exports.__ΩFormatBigPositiveInt = __ΩFormatBigPositiveInt;
+exports.__ΩFormatBigUInt64 = __ΩFormatBigUInt64;
+//# sourceMappingURL=defaultBigNumberFormats.cjs.map

package/.dist/cjs/src/bigint/defaultBigNumberFormats.cjs.map

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

package/.dist/cjs/src/bigint/defaultBigNumberFormats.d.ts

@@ -0,0 +1,29 @@
+import { FormatBigInt } from './bigIntFormat.runtype.ts';
+export type FormatBigPositive = FormatBigInt<{
+    min: 0n;
+}>;
+export type FormatBigNegative = FormatBigInt<{
+    max: 0n;
+}>;
+export type FormatBigPositiveInt = FormatBigInt<{
+    min: 0n;
+    multipleOf: 1n;
+}>;
+export type FormatBigNegativeInt = FormatBigInt<{
+    max: 0n;
+    multipleOf: 1n;
+}>;
+export type FormatBigInt64 = FormatBigInt<{
+    min: -9223372036854775808n;
+    max: 9223372036854775807n;
+}>;
+export type FormatBigUInt64 = FormatBigInt<{
+    min: 0n;
+    max: 18446744073709551615n;
+}>;
+export declare type __ΩFormatBigPositive = any[];
+export declare type __ΩFormatBigNegative = any[];
+export declare type __ΩFormatBigPositiveInt = any[];
+export declare type __ΩFormatBigNegativeInt = any[];
+export declare type __ΩFormatBigInt64 = any[];
+export declare type __ΩFormatBigUInt64 = any[];

package/.dist/cjs/src/constants.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_bigint_bigIntFormat_runtype = require("./bigint/bigIntFormat.runtype.cjs");
+const src_number_numberFormat_runtype = require("./number/numberFormat.runtype.cjs");
+require("./type-formats-pure-fns.cjs");
+const src_string_date_runtype = require("./string/date.runtype.cjs");
+const src_string_dateTime_runtype = require("./string/dateTime.runtype.cjs");
+const src_string_time_runtype = require("./string/time.runtype.cjs");
+const src_string_email_runtype = require("./string/email.runtype.cjs");
+const src_string_domain_runtype = require("./string/domain.runtype.cjs");
+const src_string_url_runtype = require("./string/url.runtype.cjs");
+const src_string_ip_runtype = require("./string/ip.runtype.cjs");
+const src_string_uuid_runtype = require("./string/uuid.runtype.cjs");
+const src_string_stringFormat_runtype = require("./string/stringFormat.runtype.cjs");
+const FormatNames = {
+  // String formats
+  stringFormat: src_string_stringFormat_runtype.StringRunTypeFormat.id,
+  uuid: src_string_uuid_runtype.UUIDRunTypeFormat.id,
+  email: src_string_email_runtype.EmailRunTypeFormat.id,
+  url: src_string_url_runtype.URLRunTypeFormat.id,
+  domain: src_string_domain_runtype.DomainRunTypeFormat.id,
+  ip: src_string_ip_runtype.IPRunTypeFormat.id,
+  date: src_string_date_runtype.DateStringRunTypeFormat.id,
+  time: src_string_time_runtype.TimeStringRunTypeFormat.id,
+  dateTime: src_string_dateTime_runtype.DateTimeRunTypeFormat.id,
+  // Number formats
+  numberFormat: src_number_numberFormat_runtype.NumberRunTypeFormat.id,
+  // BigInt formats
+  bigintFormat: src_bigint_bigIntFormat_runtype.BigIntRunTypeFormat.id
+};
+const __ΩFormatName = [() => FormatNames, () => FormatNames, "FormatName", 'i!i"gfw#y'];
+exports.FormatNames = FormatNames;
+exports.__ΩFormatName = __ΩFormatName;
+//# sourceMappingURL=constants.cjs.map

package/.dist/cjs/src/constants.cjs.map

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

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

@@ -0,0 +1,15 @@
+export declare const FormatNames: {
+    readonly stringFormat: "stringFormat";
+    readonly uuid: "uuid";
+    readonly email: string;
+    readonly url: "url";
+    readonly domain: "domain";
+    readonly ip: string;
+    readonly date: "date";
+    readonly time: "time";
+    readonly dateTime: "dateTime";
+    readonly numberFormat: "numberFormat";
+    readonly bigintFormat: "bigintFormat";
+};
+export type FormatName = (typeof FormatNames)[keyof typeof FormatNames];
+export declare type __ΩFormatName = any[];

package/.dist/cjs/src/constants.mock.cjs

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const __ΩEMAIL_NAME_SAMPLES = ["john.doe", "jane.smith", "admin", "support", "contact", "info", "sales", "marketing", "hello", "feedback", "user123", "test.account", "random.name", "developer", "webmaster", "juan.perez", "maria.garcia", "soporte", "contacto", "ventas", "informacion", "hola", "usuario", "prueba", "desarrollador", "jean.dupont", "marie.curie", "contact", "support", "vente", "bonjour", "utilisateur", "testeur", "developpeur", "hans.schmidt", "anna.müller", "kontakt", "hilfe", "verkauf", "benutzer", "testkonto", "entwickler", "giuseppe.rossi", "maria.bianchi", "contatto", "supporto", "vendite", "utente", "prova", "sviluppatore", "joao.silva", "maria.oliveira", "contato", "suporte", "vendas", "usuario", "teste", "desenvolvedor", "홍길동", "김철수", "고객지원", "연락처", "판매", "사용자", "山田太郎", "鈴木花子", "情報", "サポート", "日本語", "テスト", "携帯", "電子", "李伟", "王芳", "张三", "联系", "测试", "用户", "开发", "arjun.sharma", "priya.kumar", "support", "contact", "vikas", "pariksha", "upayogakarta", "иван.иванов", "анна.петровна", "поддержка", "контакт", "продажи", "пользователь", "разработчик", "alpha.beta", "charlie.delta", "test123", "mock.user", "example.name", "first.last", "nickname", "alias", "temp.account", "demo.user", "EMAIL_NAME_SAMPLES", "P.!.\".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8.9.:.;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.[.\\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.{.|.}.~..€..‚.ƒ.„.….†.‡Gwˆy"];
+const __ΩEMAIL_SAMPLES = ["john.doe@mion.io", "jane.smith@rpc.org", "admin@wiki.org", "support@www.mion.org", "contact@www.api.org", "info@arch.org", "sales@ccmns.org", "marketing@eff.org", "hello@fsf.org", "feedback@opensource.org", "user123@node.org", "test.account@typescript.org", "random.name@rpc.org", "developer@fullstack.org", "webmaster@mion.io", "juan.perez@wiki.org", "maria.garcia@arch.org", "soporte@ccmns.org", "contacto@eff.org", "ventas@fsf.org", "informacion@opensource.org", "hola@node.org", "usuario@typescript.org", "prueba@rpc.org", "desarrollador@fullstack.org", "jean.dupont@mion.io", "marie.curie@wiki.org", "vente@arch.org", "bonjour@ccmns.org", "utilisateur@eff.org", "testeur@fsf.org", "developpeur@opensource.org", "anna.müller@node.org", "anna.schmidt@typescript.org", "kontakt@rpc.org", "hilfe@fullstack.org", "verkauf@mion.io", "benutzer@wiki.org", "entwickler@arch.org", "王芳@ccmns.org", "联系@eff.org", "测试@fsf.org", "ceshi@opensource.org", "张三@node.org", "kaifa@typescript.org", "arjun.sharma@rpc.org", "priya.kumar@fullstack.org", "vikas@mion.io", "pariksha@wiki.org", "upayogakarta@arch.org", "иван.иванов@ccmns.org", "анна.петровна@eff.org", "поддержка@fsf.org", "контакт@opensource.org", "продажи@node.org", "пользователь@typescript.org", "разработчик@rpc.org", "alpha.beta@fullstack.org", "charlie.delta@mion.io", "test123@wiki.org", "mock.user@arch.org", "example.name@ccmns.org", "first.last@eff.org", "nickname@fsf.org", "alias@opensource.org", "temp.account@node.org", "demo.user@typescript.org", "email+tag@mion.io", "email-with-hyphen@rpc.org", "email_with_underscore@wiki.org", "very.common@arch.org", "!#$%&'*+-/=?^_`{|}~@ccmns.org", '"quoted"@eff.org', '"very.(),:;<>[]\\"@opensource.org', "user.name+tag+sorting@example.com", "x@example.com", "example-indeed@strange-example.com", "test/test@test.com", 'very."(),:;<>[]..very.unusual@strange.example.com', "user%example.com@mion.io", "user-@example.org", "EMAIL_SAMPLES", "P.!.\".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8.9.:.;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.V.W.X.Y.Z.[.\\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.qGwry"];
+const __ΩEMAIL_SAMPLES_PUNYCODE = ["john.doe@mion.io", "jane.smith@rpc.org", "admin@xn--e1afmkfd.xn--p1ai", "support@xn--80aaicww6a.xn--p1acf", "juan.perez@wiki.org", "maria.garcia@arch.org", "soporte@xn--mgbh0fb.xn--kgbechtv", "contacto@xn--fiqz9s.xn--fiqs8s", "иван.иванов@ccmns.org", "анна.петровна@xn--80adxhks.xn--p1ai", "поддержка@xn--d1acufc.xn--j1amh", "user.name+tag+sorting@example.com", "user@sub-domain.example-site.com", "user@domain.with-number123.com", "user@xn--80akhbyknj4f.xn--p1ai", "x@xn--mgberp4a5d4ar.xn--mgbaam7a8h", "test@xn--qxam.xn--zckzah", "info@xn--9n2bp8q.xn--9t4b11yi5a", "EMAIL_SAMPLES_PUNYCODE", `P.!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2Gw3y`];
+const __ΩURL_SAMPLES = ["https://mion.io", "https://rpc.org", "http://wiki.org", "https://www.mion.org", "http://www.api.org", "https://arch.org/path/to/resource", "http://ccmns.org/path/to/resource", "https://eff.org?query=param", "http://fsf.org?query=param#hello-world", "https://opensource.org#fragment", "http://node.org#fragment", "https://subdomain.typescript.org", "http://subdomain.rpc.org", "https://fullstack.org:8080", "http://localhost:8080/path/to/resource", "https://127.0.0.1:8080/path/to/resource", "https://254.60.167.80:80/path/to/resource", "http://:8080/path/to/resource", "http://[::1]:8080/path/to/resource", "http://[::]:8080/path/to/resource?query=param", "http://[::1]:8080/path/to/resource#fragment", "http://[::1]/path/to/resource", "ws://mion.io/socket", "ws://websocket.org/socket", "wss://socket.io/socket", "ws://live.com/socket?query=param", "wss://sock.org/socket?query=param#fragment", "ws://socketcluster.io/socket#fragment", "wss://developer..dev:8080/socket", "ws://fast.com:8080/socket?query=param", "ftp://example.com/file.txt", "ftps://example.com/file.txt", "URL_SAMPLES", `P.!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6.7.8.9.:.;.<.=.>.?.@GwAy`];
+const __ΩFILE_URL_SAMPLES = ["file:///path/to/file.txt", "file:///C:/path/to/file.txt", "file://localhost/path/to/file.txt", "file:///home/user/file.txt", "file://example.com/path/to/file.txt", "file:///C:/Users/User/Documents/file.txt", "file:///tmp/file.txt", "file:///var/log/syslog", "file:///path/to/file.txt?query=param", "file:///C:/path/to/file.txt?query=param", "file:///path/to/file%20with%20spaces.txt", "file:///path/to/file@with@special#characters.txt", "file://localhost/path/to/file.txt", "file://localhost/C:/path/to/file.txt", "file://localhost/home/user/file.txt", "file://127.0.0.1:890/example.com/path/to/file.txt", "file://localhost/path/to/file.txt?query=param", "file:///home/user/file.txt?query=param", "FILE_URL_SAMPLES", `P.!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2Gw3y`];
+const __ΩHTTP_URL_SAMPLES = ["https://mion.io", "https://rpc.org", "http://wiki.org", "https://www.mion.org", "http://www.api.org", "https://arch.org/path/to/resource", "http://ccmns.org/path/to/resource", "https://eff.org?query=param", "http://fsf.org?query=param#hello-world", "https://opensource.org#fragment", "http://node.org#fragment", "https://subdomain.typescript.org", "http://subdomain.rpc.org", "https://fullstack.org:8080", "http://localhost:8080/path/to/resource", "https://127.0.0.1:8080/path/to/resource", "https://254.60.167.80:80/path/to/resource", "http://:8080/path/to/resource", "http://[::1]:8080/path/to/resource", "http://[::]:8080/path/to/resource?query=param", "http://[::1]:8080/path/to/resource#fragment", "http://[::1]/path/to/resource", "HTTP_URL_SAMPLES", `P.!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4.5.6Gw7y`];
+const __ΩSOCIAL_MEDIA_URL_SAMPLES = ["https://www.facebook.com/user", "https://twitter.com/user", "https://www.instagram.com/user/", "https://www.linkedin.com/in/user/", "https://www.tiktok.com/@user", "https://www.youtube.com/c/user", "https://www.snapchat.com/add/user", "https://www.pinterest.com/user?query=param", "https://www.reddit.com/user/user#fragment", "https://www.whatsapp.com/user/", "http://www.facebook.com/user", "http://twitter.com/user", "http://www.instagram.com/user/", "http://www.linkedin.com/in/user/?query=param", "http://www.tiktok.com/@user", "http://www.youtube.com/c/user", "http://www.snapchat.com/add/user?query=param#fragment", "http://www.pinterest.com/user/", "http://www.reddit.com/user/user/#fragment", "http://www.whatsapp.com/user/", "SOCIAL_MEDIA_URL_SAMPLES", `P.!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3.4Gw5y`];
+const __ΩSOCIAL_MEDIA_DOMAINS_SAMPLES = ["facebook", "twitter", "instagram", "linkedin", "tiktok", "youtube", "snapchat", "pinterest", "reddit", "whatsapp", "SOCIAL_MEDIA_DOMAINS_SAMPLES", `P.!.".#.$.%.&.'.(.).*Gw+y`];
+const TLD_SAMPLES = [
+  "com",
+  "org",
+  "net",
+  "io",
+  "ai",
+  "app",
+  "co",
+  "dev",
+  "tech",
+  "co.uk",
+  "com.au",
+  "com.br",
+  "com.mx",
+  "com.ar"
+];
+const NAME_SAMPLES = [
+  "mion",
+  "mionkit",
+  "example",
+  "gogle",
+  "fcbook",
+  "amzn",
+  "twitt",
+  "insta",
+  "linked",
+  "yoube",
+  "pinturist",
+  "mion",
+  "mionkit",
+  "wiki",
+  "red",
+  "line",
+  "hello",
+  "world",
+  "test",
+  "random",
+  "user",
+  "developer",
+  "webmaster",
+  "admin",
+  "support",
+  "contact",
+  "info",
+  "mion",
+  "mionkit"
+];
+const TLD_CHARS = "abcdefghijklmnopqrstuvwxyz";
+const NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+const NAME_CHARS_UNICODE = "abcdefghijklmnopqrstuvwxyz0123456789абвгдеёжзийклмнопрстуфхцчшщъыьэюяあいうえおかきくけこさしすせそたちつてとなにぬねのアイウエオカキクケコサシスセソタチツテト中国网址域名汉字电脑互联网技术计算机软件编程한국어도메인이름인터넷기술컴퓨터소프트웨어프로그래밍ابتثجحخدذرزسشصضطظعغفقكلمنهوي";
+const INTERNET_PROTOCOLS = ["http", "https", "ftp", "ftps", "ws", "wss", "file"];
+const EMAIL_NAME_SAMPLES_ARRAY = [
+  "john.doe",
+  "jane.smith",
+  "admin",
+  "support",
+  "contact",
+  "info",
+  "sales",
+  "marketing",
+  "hello",
+  "feedback",
+  "user123",
+  "test.account",
+  "random.name",
+  "developer",
+  "webmaster",
+  "juan.perez",
+  "maria.garcia",
+  "soporte",
+  "contacto",
+  "ventas",
+  "informacion",
+  "hola",
+  "usuario",
+  "prueba",
+  "desarrollador",
+  "jean.dupont",
+  "marie.curie",
+  "vente",
+  "bonjour",
+  "utilisateur",
+  "testeur",
+  "developpeur"
+];
+exports.EMAIL_NAME_SAMPLES_ARRAY = EMAIL_NAME_SAMPLES_ARRAY;
+exports.INTERNET_PROTOCOLS = INTERNET_PROTOCOLS;
+exports.NAME_CHARS = NAME_CHARS;
+exports.NAME_CHARS_UNICODE = NAME_CHARS_UNICODE;
+exports.NAME_SAMPLES = NAME_SAMPLES;
+exports.TLD_CHARS = TLD_CHARS;
+exports.TLD_SAMPLES = TLD_SAMPLES;
+exports.__ΩEMAIL_NAME_SAMPLES = __ΩEMAIL_NAME_SAMPLES;
+exports.__ΩEMAIL_SAMPLES = __ΩEMAIL_SAMPLES;
+exports.__ΩEMAIL_SAMPLES_PUNYCODE = __ΩEMAIL_SAMPLES_PUNYCODE;
+exports.__ΩFILE_URL_SAMPLES = __ΩFILE_URL_SAMPLES;
+exports.__ΩHTTP_URL_SAMPLES = __ΩHTTP_URL_SAMPLES;
+exports.__ΩSOCIAL_MEDIA_DOMAINS_SAMPLES = __ΩSOCIAL_MEDIA_DOMAINS_SAMPLES;
+exports.__ΩSOCIAL_MEDIA_URL_SAMPLES = __ΩSOCIAL_MEDIA_URL_SAMPLES;
+exports.__ΩURL_SAMPLES = __ΩURL_SAMPLES;
+//# sourceMappingURL=constants.mock.cjs.map

package/.dist/cjs/src/constants.mock.cjs.map

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