@mionjs/type-formats 0.8.0-alpha.0

package/.dist/esm/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/esm/src/bigint/bigIntFormat.runtype.js

@@ -0,0 +1,152 @@
+import { registerFormatter, BaseRunTypeFormat, random, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { ReflectionKind } from "@deepkit/type";
+import { paramVal } from "../utils.js";
+const BIGINT64_MIN = -9223372036854775808n;
+const BIGINT64_MAX = 9223372036854775807n;
+const BIGUINT64_MIN = 0n;
+const BIGUINT64_MAX = 18446744073709551615n;
+class BigIntRunTypeFormat extends BaseRunTypeFormat {
+  static id = "bigintFormat";
+  kind = 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 = paramVal(params.max);
+      conditions.push(`${v} <= ${maxVal}n`);
+    }
+    if (params.min !== void 0) {
+      const minVal = paramVal(params.min);
+      conditions.push(`${v} >= ${minVal}n`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = paramVal(params.lt);
+      conditions.push(`${v} < ${ltVal}n`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = paramVal(params.gt);
+      conditions.push(`${v} > ${gtVal}n`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = 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 = paramVal(params.max);
+      conditions.push(`if (${v} > ${maxVal}n) ${errFn("max", maxVal)}`);
+    }
+    if (params.min !== void 0) {
+      const minVal = paramVal(params.min);
+      conditions.push(`if (${v} < ${minVal}n) ${errFn("min", minVal)}`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = paramVal(params.lt);
+      conditions.push(`if (${v} >= ${ltVal}n) ${errFn("lt", ltVal)}`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = paramVal(params.gt);
+      conditions.push(`if (${v} <= ${gtVal}n) ${errFn("gt", gtVal)}`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = 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 ? paramVal(params.min) : -99999n;
+    let max = params.max !== void 0 ? paramVal(params.max) : 99999n;
+    if (params.gt !== void 0) {
+      const gtVal = paramVal(params.gt);
+      min = gtVal + 1n;
+    }
+    if (params.lt !== void 0) {
+      const ltVal = 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(random(minNum, maxNum));
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = 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 && paramVal(params.min) > paramVal(params.max)) {
+      throw new Error(`min cannot be greater than max in ${this.printPath(rt)}`);
+    }
+    if (params.gt && params.lt && paramVal(params.gt) >= 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 = 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 ? paramVal(params.min) : void 0;
+  const max = params.max !== void 0 ? 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 = registerFormatter(new BigIntRunTypeFormat());
+const __ΩFormatBigInt = ["P", "BrandName", () => ___TypeFormat, () => BigIntRunTypeFormat.id, "FormatBigInt", 'PMc!!c"*i$e!!e!"o#%w%y'];
+export {
+  BIGINT_RUN_TYPE_FORMATTER,
+  BigIntRunTypeFormat,
+  __ΩFormatBigInt
+};
+//# sourceMappingURL=bigIntFormat.runtype.js.map

package/.dist/esm/src/bigint/bigIntFormat.runtype.js.map

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

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

@@ -0,0 +1,16 @@
+import { __ΩFormatBigInt as ___FormatBigInt } from "./bigIntFormat.runtype.js";
+const __ΩFormatBigPositive = [() => ___FormatBigInt, 0n, "min", "FormatBigPositive", 'P."4#Mo!"w$y'];
+const __ΩFormatBigNegative = [() => ___FormatBigInt, 0n, "max", "FormatBigNegative", 'P."4#Mo!"w$y'];
+const __ΩFormatBigPositiveInt = [() => ___FormatBigInt, 0n, "min", 1n, "multipleOf", "FormatBigPositiveInt", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatBigNegativeInt = [() => ___FormatBigInt, 0n, "max", 1n, "multipleOf", "FormatBigNegativeInt", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatBigInt64 = [() => ___FormatBigInt, -9223372036854775808n, "min", 9223372036854775807n, "max", "FormatBigInt64", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatBigUInt64 = [() => ___FormatBigInt, 0n, "min", 18446744073709551615n, "max", "FormatBigUInt64", 'P."4#.$4%Mo!"w&y'];
+export {
+  __ΩFormatBigInt64,
+  __ΩFormatBigNegative,
+  __ΩFormatBigNegativeInt,
+  __ΩFormatBigPositive,
+  __ΩFormatBigPositiveInt,
+  __ΩFormatBigUInt64
+};
+//# sourceMappingURL=defaultBigNumberFormats.js.map

package/.dist/esm/src/bigint/defaultBigNumberFormats.js.map

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

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

@@ -0,0 +1,34 @@
+import { BigIntRunTypeFormat } from "./bigint/bigIntFormat.runtype.js";
+import { NumberRunTypeFormat } from "./number/numberFormat.runtype.js";
+import "./type-formats-pure-fns.js";
+import { DateStringRunTypeFormat } from "./string/date.runtype.js";
+import { DateTimeRunTypeFormat } from "./string/dateTime.runtype.js";
+import { TimeStringRunTypeFormat } from "./string/time.runtype.js";
+import { EmailRunTypeFormat } from "./string/email.runtype.js";
+import { DomainRunTypeFormat } from "./string/domain.runtype.js";
+import { URLRunTypeFormat } from "./string/url.runtype.js";
+import { IPRunTypeFormat } from "./string/ip.runtype.js";
+import { UUIDRunTypeFormat } from "./string/uuid.runtype.js";
+import { StringRunTypeFormat } from "./string/stringFormat.runtype.js";
+const FormatNames = {
+  // String formats
+  stringFormat: StringRunTypeFormat.id,
+  uuid: UUIDRunTypeFormat.id,
+  email: EmailRunTypeFormat.id,
+  url: URLRunTypeFormat.id,
+  domain: DomainRunTypeFormat.id,
+  ip: IPRunTypeFormat.id,
+  date: DateStringRunTypeFormat.id,
+  time: TimeStringRunTypeFormat.id,
+  dateTime: DateTimeRunTypeFormat.id,
+  // Number formats
+  numberFormat: NumberRunTypeFormat.id,
+  // BigInt formats
+  bigintFormat: BigIntRunTypeFormat.id
+};
+const __ΩFormatName = [() => FormatNames, () => FormatNames, "FormatName", 'i!i"gfw#y'];
+export {
+  FormatNames,
+  __ΩFormatName
+};
+//# sourceMappingURL=constants.js.map

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

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

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

@@ -0,0 +1,335 @@
+export type 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'
+];
+export type 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'
+];
+export type 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'
+];
+export type 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'
+];
+export type 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'
+];
+export type 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'
+];
+export type 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/'
+];
+export type SOCIAL_MEDIA_DOMAINS_SAMPLES = [
+    'facebook',
+    'twitter',
+    'instagram',
+    'linkedin',
+    'tiktok',
+    'youtube',
+    'snapchat',
+    'pinterest',
+    'reddit',
+    'whatsapp'
+];
+export declare const TLD_SAMPLES: string[];
+export declare const NAME_SAMPLES: string[];
+export declare const TLD_CHARS = "abcdefghijklmnopqrstuvwxyz";
+export declare const NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+export declare const NAME_CHARS_UNICODE: string;
+export declare const INTERNET_PROTOCOLS: string[];
+export declare const EMAIL_NAME_SAMPLES_ARRAY: string[];
+export declare type __ΩEMAIL_NAME_SAMPLES = any[];
+export declare type __ΩEMAIL_SAMPLES = any[];
+export declare type __ΩEMAIL_SAMPLES_PUNYCODE = any[];
+export declare type __ΩURL_SAMPLES = any[];
+export declare type __ΩFILE_URL_SAMPLES = any[];
+export declare type __ΩHTTP_URL_SAMPLES = any[];
+export declare type __ΩSOCIAL_MEDIA_URL_SAMPLES = any[];
+export declare type __ΩSOCIAL_MEDIA_DOMAINS_SAMPLES = any[];