@mionjs/type-formats 0.8.0-alpha.0

package/.dist/cjs/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[];

package/.dist/cjs/src/number/defaultNumberFormats.cjs

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

package/.dist/cjs/src/number/defaultNumberFormats.cjs.map

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

package/.dist/cjs/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/cjs/src/number/numberFormat.runtype.cjs

@@ -0,0 +1,214 @@
+"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");
+class NumberRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "numberFormat";
+  kind = type.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 = src_utils.paramVal(params.max);
+      conditions.push(`${v} <= ${maxVal}`);
+    }
+    if (params.min !== void 0) {
+      const minVal = src_utils.paramVal(params.min);
+      conditions.push(`${v} >= ${minVal}`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = src_utils.paramVal(params.lt);
+      conditions.push(`${v} < ${ltVal}`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = src_utils.paramVal(params.gt);
+      conditions.push(`${v} > ${gtVal}`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = src_utils.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 = src_utils.paramVal(params.max);
+      conditions.push(`if (${v} > ${maxVal}) ${errFn("max", maxVal)}`);
+    }
+    if (params.min !== void 0) {
+      const minVal = src_utils.paramVal(params.min);
+      conditions.push(`if (${v} < ${minVal}) ${errFn("min", minVal)}`);
+    }
+    if (params.lt !== void 0) {
+      const ltVal = src_utils.paramVal(params.lt);
+      conditions.push(`if (${v} >= ${ltVal}) ${errFn("lt", ltVal)}`);
+    }
+    if (params.gt !== void 0) {
+      const gtVal = src_utils.paramVal(params.gt);
+      conditions.push(`if (${v} <= ${gtVal}) ${errFn("gt", gtVal)}`);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = src_utils.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 type2 = "S";
+    const sεr = comp.args.sεr;
+    const params = this.getParams(rt);
+    const isFloat = params.float !== void 0 ? src_utils.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: type2 };
+    const isInt = params.integer !== void 0 ? src_utils.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: type2 };
+        case isUint16:
+          return { code: `${sεr}.view.setUint16(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 2)`, type: type2 };
+        case isUint32:
+          return { code: `${sεr}.view.setUint32(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 4)`, type: type2 };
+        case isInt8:
+          return { code: `${sεr}.view.setInt8(${sεr}.index++, ${comp.vλl})`, type: type2 };
+        case isInt16:
+          return { code: `${sεr}.view.setInt16(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 2)`, type: type2 };
+        case isInt32:
+          return { code: `${sεr}.view.setInt32(${sεr}.index, ${comp.vλl}, 1, ${sεr}.index += 4)`, type: type2 };
+        default:
+          return { code: floatCode, type: type2 };
+      }
+    }
+    return { code: floatCode, type: "S" };
+  }
+  emitFromBinary(comp, rt) {
+    const type2 = "E";
+    const dεs = comp.args.dεs;
+    const params = this.getParams(rt);
+    const isFloat = params.float !== void 0 ? src_utils.paramVal(params.float) : false;
+    const floatCode = `${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8))`;
+    if (isFloat)
+      return { code: floatCode, type: type2 };
+    const isInt = params.integer !== void 0 ? src_utils.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: type2 };
+        case isUint16:
+          return { code: `${dεs}.view.getUint16(${dεs}.index, 1, ${dεs}.index += 2)`, type: type2 };
+        case isUint32:
+          return { code: `${dεs}.view.getUint32(${dεs}.index, 1, ${dεs}.index += 4)`, type: type2 };
+        case isInt8:
+          return { code: `${dεs}.view.getInt8(${dεs}.index++)`, type: type2 };
+        case isInt16:
+          return { code: `${dεs}.view.getInt16(${dεs}.index, 1, ${dεs}.index += 2)`, type: type2 };
+        case isInt32:
+          return { code: `${dεs}.view.getInt32(${dεs}.index, 1, ${dεs}.index += 4)`, type: type2 };
+        default:
+          return { code: floatCode, type: type2 };
+      }
+    }
+    return { code: floatCode, type: type2 };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    let min = params.min !== void 0 ? src_utils.paramVal(params.min) : -99999;
+    let max = params.max !== void 0 ? src_utils.paramVal(params.max) : 99999;
+    if (params.gt !== void 0) {
+      const epsilon = params.float ? 0.01 : 1;
+      const gtVal = src_utils.paramVal(params.gt);
+      min = Math.max(min, gtVal + epsilon);
+    }
+    if (params.lt !== void 0) {
+      const epsilon = params.float ? 0.01 : 1;
+      const ltVal = src_utils.paramVal(params.lt);
+      max = Math.min(max, ltVal - epsilon);
+    }
+    let result;
+    if (params.integer) {
+      min = Math.ceil(min);
+      max = Math.floor(max);
+      result = runTypes.random(min, max);
+    } else {
+      result = min + Math.random() * (max - min);
+    }
+    if (params.multipleOf !== void 0) {
+      const multipleOfVal = src_utils.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 && 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)}`);
+      }
+      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 ? src_utils.paramVal(params.min) : Number.MIN_SAFE_INTEGER;
+  const max = params.max !== void 0 ? src_utils.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 = runTypes.registerFormatter(new NumberRunTypeFormat());
+const __ΩFormatNumber = ["P", "BrandName", () => runTypes.__ΩTypeFormat, () => NumberRunTypeFormat.id, "FormatNumber", `b!!c"'i$e!!e!"o#%w%y`];
+exports.NUMBER_RUN_TYPE_FORMATTER = NUMBER_RUN_TYPE_FORMATTER;
+exports.NumberRunTypeFormat = NumberRunTypeFormat;
+exports.__ΩFormatNumber = __ΩFormatNumber;
+//# sourceMappingURL=numberFormat.runtype.cjs.map

package/.dist/cjs/src/number/numberFormat.runtype.cjs.map

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

package/.dist/cjs/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[];