@mionjs/type-formats 0.8.0-alpha.0

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

@@ -0,0 +1,111 @@
+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"
+];
+export {
+  EMAIL_NAME_SAMPLES_ARRAY,
+  INTERNET_PROTOCOLS,
+  NAME_CHARS,
+  NAME_CHARS_UNICODE,
+  NAME_SAMPLES,
+  TLD_CHARS,
+  TLD_SAMPLES,
+  __ΩEMAIL_NAME_SAMPLES,
+  __ΩEMAIL_SAMPLES,
+  __ΩEMAIL_SAMPLES_PUNYCODE,
+  __ΩFILE_URL_SAMPLES,
+  __ΩHTTP_URL_SAMPLES,
+  __ΩSOCIAL_MEDIA_DOMAINS_SAMPLES,
+  __ΩSOCIAL_MEDIA_URL_SAMPLES,
+  __ΩURL_SAMPLES
+};
+//# sourceMappingURL=constants.mock.js.map

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

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

package/.dist/esm/src/number/defaultNumberFormats.d.ts

@@ -0,0 +1,63 @@
+import { FormatNumber } from './numberFormat.runtype.ts';
+export type FormatInteger = FormatNumber<{
+    integer: true;
+}, 'integer'>;
+export type FormatFloat = FormatNumber<{
+    float: true;
+}, 'float'>;
+export type FormatPositive = FormatNumber<{
+    min: 0;
+}, 'positive'>;
+export type FormatNegative = FormatNumber<{
+    max: 0;
+}, 'negative'>;
+export type FormatPositiveInt = FormatNumber<{
+    min: 0;
+    integer: true;
+}, 'positiveInt'>;
+export type FormatNegativeInt = FormatNumber<{
+    max: 0;
+    integer: true;
+}, 'negativeInt'>;
+export type FormatInt8 = FormatNumber<{
+    integer: true;
+    min: -128;
+    max: 127;
+}, 'int8'>;
+export type FormatInt16 = FormatNumber<{
+    integer: true;
+    min: -32768;
+    max: 32767;
+}, 'int16'>;
+export type FormatInt32 = FormatNumber<{
+    integer: true;
+    min: -2147483648;
+    max: 2147483647;
+}, 'int32'>;
+export type FormatUInt8 = FormatNumber<{
+    integer: true;
+    min: 0;
+    max: 255;
+}, 'uint8'>;
+export type FormatUInt16 = FormatNumber<{
+    integer: true;
+    min: 0;
+    max: 65535;
+}, 'uint16'>;
+export type FormatUInt32 = FormatNumber<{
+    integer: true;
+    min: 0;
+    max: 4294967295;
+}, 'uint32'>;
+export declare type __ΩFormatInteger = any[];
+export declare type __ΩFormatFloat = any[];
+export declare type __ΩFormatPositive = any[];
+export declare type __ΩFormatNegative = any[];
+export declare type __ΩFormatPositiveInt = any[];
+export declare type __ΩFormatNegativeInt = any[];
+export declare type __ΩFormatInt8 = any[];
+export declare type __ΩFormatInt16 = any[];
+export declare type __ΩFormatInt32 = any[];
+export declare type __ΩFormatUInt8 = any[];
+export declare type __ΩFormatUInt16 = any[];
+export declare type __ΩFormatUInt32 = any[];

package/.dist/esm/src/number/defaultNumberFormats.js

@@ -0,0 +1,28 @@
+import { __ΩFormatNumber as ___FormatNumber } from "./numberFormat.runtype.js";
+const __ΩFormatInteger = [() => ___FormatNumber, true, "integer", "integer", "FormatInteger", 'P."4#M.$o!#w%y'];
+const __ΩFormatFloat = [() => ___FormatNumber, true, "float", "float", "FormatFloat", 'P."4#M.$o!#w%y'];
+const __ΩFormatPositive = [() => ___FormatNumber, 0, "min", "positive", "FormatPositive", 'P."4#M.$o!#w%y'];
+const __ΩFormatNegative = [() => ___FormatNumber, 0, "max", "negative", "FormatNegative", 'P."4#M.$o!#w%y'];
+const __ΩFormatPositiveInt = [() => ___FormatNumber, 0, "min", true, "integer", "positiveInt", "FormatPositiveInt", `P."4#.$4%M.&o!#w'y`];
+const __ΩFormatNegativeInt = [() => ___FormatNumber, 0, "max", true, "integer", "negativeInt", "FormatNegativeInt", `P."4#.$4%M.&o!#w'y`];
+const __ΩFormatInt8 = [() => ___FormatNumber, true, "integer", -128, "min", 127, "max", "int8", "FormatInt8", `P."4#.$4%.&4'M.(o!#w)y`];
+const __ΩFormatInt16 = [() => ___FormatNumber, true, "integer", -32768, "min", 32767, "max", "int16", "FormatInt16", `P."4#.$4%.&4'M.(o!#w)y`];
+const __ΩFormatInt32 = [() => ___FormatNumber, true, "integer", -2147483648, "min", 2147483647, "max", "int32", "FormatInt32", `P."4#.$4%.&4'M.(o!#w)y`];
+const __ΩFormatUInt8 = [() => ___FormatNumber, true, "integer", 0, "min", 255, "max", "uint8", "FormatUInt8", `P."4#.$4%.&4'M.(o!#w)y`];
+const __ΩFormatUInt16 = [() => ___FormatNumber, true, "integer", 0, "min", 65535, "max", "uint16", "FormatUInt16", `P."4#.$4%.&4'M.(o!#w)y`];
+const __ΩFormatUInt32 = [() => ___FormatNumber, true, "integer", 0, "min", 4294967295, "max", "uint32", "FormatUInt32", `P."4#.$4%.&4'M.(o!#w)y`];
+export {
+  __ΩFormatFloat,
+  __ΩFormatInt16,
+  __ΩFormatInt32,
+  __ΩFormatInt8,
+  __ΩFormatInteger,
+  __ΩFormatNegative,
+  __ΩFormatNegativeInt,
+  __ΩFormatPositive,
+  __ΩFormatPositiveInt,
+  __ΩFormatUInt16,
+  __ΩFormatUInt32,
+  __ΩFormatUInt8
+};
+//# sourceMappingURL=defaultNumberFormats.js.map

package/.dist/esm/src/number/defaultNumberFormats.js.map

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

package/.dist/esm/src/number/numberFormat.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_Number } from '@mionjs/core';
+type BinarySerializer = BaseFnCompiler<typeof jitBinarySerializerArgs, typeof JitFunctions.toBinary.id>;
+type BinaryDeserializer = BaseFnCompiler<typeof jitBinaryDeserializerArgs, typeof JitFunctions.fromBinary.id>;
+export declare class NumberRunTypeFormat extends BaseRunTypeFormat<FormatParams_Number> {
+    static readonly id: "numberFormat";
+    readonly kind = ReflectionKind.number;
+    readonly name: "numberFormat";
+    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): number;
+    validateParams(rt: BaseRunType, params: FormatParams_Number): void;
+}
+export declare const NUMBER_RUN_TYPE_FORMATTER: NumberRunTypeFormat;
+export type FormatNumber<P extends Partial<FormatParams_Number>, BrandName extends string = never> = TypeFormat<number, typeof NumberRunTypeFormat.id, P, BrandName>;
+export {};
+export declare type __ΩFormatNumber = any[];

package/.dist/esm/src/number/numberFormat.runtype.js

@@ -0,0 +1,214 @@
+import { registerFormatter, BaseRunTypeFormat, random, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { ReflectionKind } from "@deepkit/type";
+import { paramVal } from "../utils.js";
+class NumberRunTypeFormat extends BaseRunTypeFormat {
+  static id = "numberFormat";
+  kind = ReflectionKind.number;
+  name = NumberRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const v = comp.vλl;
+    const conditions = [];
+    if (params.integer) {
+      conditions.push(`Number.isInteger(${v})`);
+    } else if (params.float) {
+      conditions.push(`!Number.isInteger(${v})`);
+    }
+    if (params.max !== void 0) {
+      const maxVal = paramVal(params.max);
+      conditions.push(`${v} <= ${maxVal}`);
+    }
+    if (params.min !== void 0) {
+      const minVal = paramVal(params.min);
+      conditions.push(`${v} >= ${minVal}`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = paramVal(params.lt);
+      conditions.push(`${v} < ${ltVal}`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = paramVal(params.gt);
+      conditions.push(`${v} > ${gtVal}`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = paramVal(params.multipleOf);
+      conditions.push(`(${v} % ${multipleOfVal} === 0)`);
+    }
+    return { code: conditions.join(" && "), 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.integer) {
+      conditions.push(`if (!Number.isInteger(${v})) ${errFn("integer", true)}`);
+    } else if (params.float) {
+      conditions.push(`if (Number.isInteger(${v})) ${errFn("float", true)}`);
+    }
+    if (params.max !== void 0) {
+      const maxVal = paramVal(params.max);
+      conditions.push(`if (${v} > ${maxVal}) ${errFn("max", maxVal)}`);
+    }
+    if (params.min !== void 0) {
+      const minVal = paramVal(params.min);
+      conditions.push(`if (${v} < ${minVal}) ${errFn("min", minVal)}`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = paramVal(params.lt);
+      conditions.push(`if (${v} >= ${ltVal}) ${errFn("lt", ltVal)}`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = paramVal(params.gt);
+      conditions.push(`if (${v} <= ${gtVal}) ${errFn("gt", gtVal)}`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = paramVal(params.multipleOf);
+      conditions.push(`if ((${v} % ${multipleOfVal} !== 0)) ${errFn("multipleOf", multipleOfVal)}`);
+    }
+    return { code: conditions.join(";"), type: "S" };
+  }
+  // No format transformation needed for numbers
+  emitFormat() {
+    return { code: void 0, type: "S" };
+  }
+  emitToBinary(comp, rt) {
+    const type = "S";
+    const sεr = comp.args.sεr;
+    const params = this.getParams(rt);
+    const isFloat = params.float !== void 0 ? paramVal(params.float) : false;
+    const floatCode = `${sεr}.view.setFloat64(${sεr}.index,${comp.vλl}, 1, (${sεr}.index += 8))`;
+    if (isFloat)
+      return { code: floatCode, type };
+    const isInt = params.integer !== void 0 ? paramVal(params.integer) : false;
+    if (isInt) {
+      const { isUint8, isUint16, isUint32, isInt8, isInt16, isInt32 } = getIntegerType(params);
+      switch (true) {
+        case isUint8:
+          return { code: `${sεr}.view.setUint8(${sεr}.index++, ${comp.vλl})`, type };
+        case isUint16:
+          return { code: `${sεr}.view.setUint16(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 2)`, type };
+        case isUint32:
+          return { code: `${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 4)`, type };
+        case isInt8:
+          return { code: `${sεr}.view.setInt8(${sεr}.index++, ${comp.vλl})`, type };
+        case isInt16:
+          return { code: `${sεr}.view.setInt16(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 2)`, type };
+        case isInt32:
+          return { code: `${sεr}.view.setInt32(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 4)`, type };
+        default:
+          return { code: floatCode, type };
+      }
+    }
+    return { code: floatCode, type: "S" };
+  }
+  emitFromBinary(comp, rt) {
+    const type = "E";
+    const dεs = comp.args.dεs;
+    const params = this.getParams(rt);
+    const isFloat = params.float !== void 0 ? paramVal(params.float) : false;
+    const floatCode = `${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8))`;
+    if (isFloat)
+      return { code: floatCode, type };
+    const isInt = params.integer !== void 0 ? paramVal(params.integer) : false;
+    if (isInt) {
+      const { isUint8, isUint16, isUint32, isInt8, isInt16, isInt32 } = getIntegerType(params);
+      switch (true) {
+        case isUint8:
+          return { code: `${dεs}.view.getUint8(${dεs}.index++)`, type };
+        case isUint16:
+          return { code: `${dεs}.view.getUint16(${dεs}.index, 1, ${dεs}.index += 2)`, type };
+        case isUint32:
+          return { code: `${dεs}.view.getUint32(${dεs}.index, 1, ${dεs}.index += 4)`, type };
+        case isInt8:
+          return { code: `${dεs}.view.getInt8(${dεs}.index++)`, type };
+        case isInt16:
+          return { code: `${dεs}.view.getInt16(${dεs}.index, 1, ${dεs}.index += 2)`, type };
+        case isInt32:
+          return { code: `${dεs}.view.getInt32(${dεs}.index, 1, ${dεs}.index += 4)`, type };
+        default:
+          return { code: floatCode, type };
+      }
+    }
+    return { code: floatCode, type };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    let min = params.min !== void 0 ? paramVal(params.min) : -99999;
+    let max = params.max !== void 0 ? paramVal(params.max) : 99999;
+    if (params.gt !== void 0) {
+      const epsilon = params.float ? 0.01 : 1;
+      const gtVal = paramVal(params.gt);
+      min = Math.max(min, gtVal + epsilon);
+    }
+    if (params.lt !== void 0) {
+      const epsilon = params.float ? 0.01 : 1;
+      const ltVal = paramVal(params.lt);
+      max = Math.min(max, ltVal - epsilon);
+    }
+    let result;
+    if (params.integer) {
+      min = Math.ceil(min);
+      max = Math.floor(max);
+      result = random(min, max);
+    } else {
+      result = min + Math.random() * (max - min);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = paramVal(params.multipleOf);
+      const factor = Math.floor(result / multipleOfVal);
+      result = factor * multipleOfVal;
+    }
+    return result;
+  }
+  validateParams(rt, params) {
+    if (params.integer && params.float) {
+      throw new Error(`Cannot specify both integer and float in ${this.printPath(rt)}`);
+    }
+    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)}`);
+      }
+      if (!Number.isInteger(multipleOfVal)) {
+        throw new Error(`multipleOf must be an integer to avoid floating-point precision issues in ${this.printPath(rt)}`);
+      }
+      if (params.float) {
+        throw new Error(`multipleOf cannot be used with float constraint as multipleOf must be an integer in ${this.printPath(rt)}`);
+      }
+    }
+  }
+}
+function getIntegerType(params) {
+  const min = params.min !== void 0 ? paramVal(params.min) : Number.MIN_SAFE_INTEGER;
+  const max = params.max !== void 0 ? paramVal(params.max) : Number.MAX_SAFE_INTEGER;
+  const isUint8 = min >= 0 && max !== void 0 && max <= 255;
+  const isUint16 = min >= 0 && max !== void 0 && max <= 65535;
+  const isUint32 = min >= 0 && max !== void 0 && max <= 4294967295;
+  const isInt8 = min >= -128 && max !== void 0 && max <= 127;
+  const isInt16 = min >= -32768 && max !== void 0 && max <= 32767;
+  const isInt32 = min >= -2147483648 && max !== void 0 && max <= 2147483647;
+  return { isUint8, isUint16, isUint32, isInt8, isInt16, isInt32 };
+}
+const NUMBER_RUN_TYPE_FORMATTER = registerFormatter(new NumberRunTypeFormat());
+const __ΩFormatNumber = ["P", "BrandName", () => ___TypeFormat, () => NumberRunTypeFormat.id, "FormatNumber", `b!!c"'i$e!!e!"o#%w%y`];
+export {
+  NUMBER_RUN_TYPE_FORMATTER,
+  NumberRunTypeFormat,
+  __ΩFormatNumber
+};
+//# sourceMappingURL=numberFormat.runtype.js.map

package/.dist/esm/src/number/numberFormat.runtype.js.map

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

package/.dist/esm/src/string/date.runtype.d.ts

@@ -0,0 +1,19 @@
+import { ReflectionKind } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler, BaseRunType, RunTypeOptions, JitCode, BaseRunTypeFormat, TypeFormat } from '@mionjs/run-types';
+import { DateFmt, FormatParams_Date } from '@mionjs/core';
+export declare class DateStringRunTypeFormat extends BaseRunTypeFormat<FormatParams_Date> {
+    static id: "date";
+    kind: ReflectionKind;
+    name: "date";
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    getFormatPureFn(format: DateFmt): import('@mionjs/core').CompiledPureFunction;
+}
+export declare const DATE_RUN_TYPE_FORMATTER: DateStringRunTypeFormat;
+export type DEFAULT_DATE_PARAMS = {
+    format: 'ISO';
+};
+export type FormatStringDate<P extends Partial<FormatParams_Date> = DEFAULT_DATE_PARAMS> = TypeFormat<string, typeof DateStringRunTypeFormat.id, P, 'date'>;
+export declare type __ΩDEFAULT_DATE_PARAMS = any[];
+export declare type __ΩFormatStringDate = any[];

package/.dist/esm/src/string/date.runtype.js

@@ -0,0 +1,88 @@
+import { ReflectionKind } from "@deepkit/type";
+import { registerFormatter, BaseRunTypeFormat, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { paramVal } from "../utils.js";
+import { cpf_isDateString_DM, cpf_isDateString_MD, cpf_isDateString_YM, cpf_isDateString_MDY, cpf_isDateString_DMY, cpf_isDateString_YMD } from "../type-formats-pure-fns.js";
+class DateStringRunTypeFormat extends BaseRunTypeFormat {
+  static id = "date";
+  kind = ReflectionKind.string;
+  name = DateStringRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const formatFn = this.getFormatPureFn(paramVal(params.format));
+    return { code: this.compilePureFunctionCall(comp, rt, formatFn).callCode, type: "E" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const isTypeCodeObj = this.emitIsType(comp, rt);
+    const isTypeCode = isTypeCodeObj.code;
+    if (!isTypeCode)
+      return { code: "", type: "S" };
+    const params = this.getParams(rt);
+    const errFn = this.getCallJitFormatErr(comp, rt, this);
+    return { code: `if (!(${isTypeCode})) ${errFn("format", paramVal(params.format))}`, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    const yy = Math.floor(Math.random() * 1e4);
+    const mm = Math.floor(Math.random() * 12) + 1;
+    const dd = Math.floor(Math.random() * getMaxDaysInMonth(yy, mm)) + 1;
+    const year = String(yy).padStart(4, "0");
+    const month = String(mm).padStart(2, "0");
+    const day = String(dd).padStart(2, "0");
+    switch (paramVal(params.format)) {
+      case "ISO":
+      case "YYYY-MM-DD":
+        return `${year}-${month}-${day}`;
+      case "DD-MM-YYYY":
+        return `${day}-${month}-${year}`;
+      case "MM-DD-YYYY":
+        return `${month}-${day}-${year}`;
+      case "YYYY-MM":
+        return `${year}-${month}`;
+      case "MM-DD":
+        return `${month}-${day}`;
+      case "DD-MM":
+        return `${day}-${month}`;
+      default:
+        throw new Error(`Invalid date format: ${paramVal(params.format)}`);
+    }
+  }
+  getFormatPureFn(format) {
+    switch (format) {
+      case "ISO":
+      case "YYYY-MM-DD":
+        return cpf_isDateString_YMD;
+      case "DD-MM-YYYY":
+        return cpf_isDateString_DMY;
+      case "MM-DD-YYYY":
+        return cpf_isDateString_MDY;
+      case "YYYY-MM":
+        return cpf_isDateString_YM;
+      case "MM-DD":
+        return cpf_isDateString_MD;
+      case "DD-MM":
+        return cpf_isDateString_DM;
+      default:
+        throw new Error(`Invalid date format: ${format}`);
+    }
+  }
+}
+function getMaxDaysInMonth(year, month) {
+  if (month === 2) {
+    if (year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0))
+      return 29;
+    return 28;
+  }
+  if (month === 4 || month === 6 || month === 9 || month === 11)
+    return 30;
+  return 31;
+}
+const DATE_RUN_TYPE_FORMATTER = registerFormatter(new DateStringRunTypeFormat());
+const __ΩDEFAULT_DATE_PARAMS = ["ISO", "format", "DEFAULT_DATE_PARAMS", 'P.!4"Mw#y'];
+const __ΩFormatStringDate = [() => __ΩDEFAULT_DATE_PARAMS, "P", () => ___TypeFormat, () => DateStringRunTypeFormat.id, "date", "FormatStringDate", 'n!c"&i$e!!.%o#%w&y'];
+export {
+  DATE_RUN_TYPE_FORMATTER,
+  DateStringRunTypeFormat,
+  __ΩDEFAULT_DATE_PARAMS,
+  __ΩFormatStringDate
+};
+//# sourceMappingURL=date.runtype.js.map

package/.dist/esm/src/string/date.runtype.js.map

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

package/.dist/esm/src/string/dateTime.runtype.d.ts

@@ -0,0 +1,26 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, TypeFormat, RunTypeOptions, BaseRunTypeFormat } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { DEFAULT_DATE_PARAMS, DateStringRunTypeFormat } from './date.runtype.ts';
+import { FormatParams_DateTime } from '@mionjs/core';
+import { DEFAULT_TIME_FORMAT_PARAMS, TimeStringRunTypeFormat } from './time.runtype.ts';
+export declare class DateTimeRunTypeFormat extends BaseRunTypeFormat<FormatParams_DateTime> {
+    static id: "dateTime";
+    kind: ReflectionKind;
+    name: "dateTime";
+    dateFormatter: DateStringRunTypeFormat;
+    timeFormatter: TimeStringRunTypeFormat;
+    constructor(parentPath?: string[]);
+    getIgnoredProps(): string[] | undefined;
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+}
+export declare const DATE_TIME_RUN_TYPE_FORMATTER: DateTimeRunTypeFormat;
+export type DEFAULT_DATE_TIME_PARAMS = {
+    date: DEFAULT_DATE_PARAMS;
+    time: DEFAULT_TIME_FORMAT_PARAMS;
+    splitChar: 'T';
+};
+export type FormatStringDateTime<P extends Partial<FormatParams_DateTime> = {}> = TypeFormat<string, typeof DateTimeRunTypeFormat.id, DEFAULT_DATE_TIME_PARAMS & P, 'dateTime'>;
+export declare type __ΩDEFAULT_DATE_TIME_PARAMS = any[];
+export declare type __ΩFormatStringDateTime = any[];