elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/type/elysia/date.mjs

@@ -1,35 +1,29 @@
 import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Codec, Refine, Unsafe } from "../typebox-type.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { cloneSchema, createSharedReference, elyType, getMeta } from "./utils.mjs";
-import { Codec, Number, Refine, Unsafe } from "typebox/type";
+import { NumberType } from "./number.mjs";
 
 //#region src/type/elysia/date.ts
 const ISO8601 = /T\d\d(?::\d\d){1,2} \d\d:\d\d$/;
 const removeTime = / (\d{2}:\d{2})$/;
-const toTimestamp = (value) => {
-	if (value instanceof Date) return value.getTime();
-	let t = new Date(value).getTime();
-	if (isNaN(t) && typeof value === "string" && /T\d{2}:\d{2}(:\d{2})? \d{2}:\d{2}$/.test(value)) t = new Date(value.replace(/ (\d{2}:\d{2})$/, "+$1")).getTime();
-	return t;
-};
+function toDate(value) {
+	const date = new Date(value);
+	return isNaN(date.getTime()) && typeof value === "string" && ISO8601.test(value) ? new Date(value.replace(removeTime, "+$1")) : date;
+}
 let StringifiedDate;
 let emptyDate;
 let sharedDate;
 function DateType(property) {
 	StringifiedDate ??= Codec(Union([
 		Refine(Unsafe({ "~kind": "Date" }), (value) => value instanceof Date, () => "must be Date"),
-		Refine(StringType(), (value) => {
-			if (!isNaN(new Date(value).getTime())) return true;
-			if (ISO8601.test(value)) return !isNaN(new Date(value.replace(removeTime, "+$1")).getTime());
-			return false;
-		}, () => "must be Date"),
-		Number()
+		Refine(StringType(), (value) => !isNaN(toDate(value).getTime()), () => "must be Date"),
+		NumberType()
 	])).Decode((value) => {
 		if (value instanceof Date) return value;
-		let d = new Date(value);
-		if (isNaN(d.getTime()) && typeof value === "string" && /T\d{2}:\d{2}(:\d{2})? \d{2}:\d{2}$/.test(value)) d = new Date(value.replace(/ (\d{2}:\d{2})$/, "+$1"));
+		const d = toDate(value);
 		if (isNaN(d.getTime())) throw new Error(`Expected Date, got: ${String(value)}`);
 		return d;
 	}).Encode((value) => {
@@ -55,7 +49,7 @@ function DateWithProperty(options) {
 	if (minMessage || maxMessage || xMinMessage || xMaxMessage || stepMessage) {
 		let failed = "must be Date";
 		schema = Refine(schema, (value) => {
-			const t = toTimestamp(value);
+			const t = value instanceof Date ? value.getTime() : toDate(value).getTime();
 			if (minMessage && t < min) {
 				failed = minMessage;
 				return false;

package/dist/type/elysia/file-type.d.ts

@@ -1,5 +1,5 @@
-import { MaybeArray, MaybePromise } from "../../types.js";
 import { FileType, FileUnit } from "../types.js";
+import { MaybeArray, MaybePromise } from "../../types.js";
 
 //#region src/type/elysia/file-type.d.ts
 type FileTypeDetector = (file: File) => MaybePromise<string | {
@@ -13,13 +13,20 @@ interface PendingFileTypeCheck {
    *  (identity walk on failure only) for a path-aware error */
   file: File;
 }
+declare const MAX_QUEUED_FILE_TYPE_CHECKS = 64;
+/** per-slot detector budget, reset on each validation pass via `epoch` */
+interface FileTypeBudget {
+  epoch: number;
+  count: number;
+  limit: number;
+}
 declare const ASYNC_REFINE = "~elyAsyncRefine";
-declare const isAsyncPredicate: (v: unknown) => boolean;
+declare const isAsyncPredicate: (v: any) => boolean;
 declare function collectFileTypeChecks(): void;
 declare function takeFileTypeChecks(): PendingFileTypeCheck[] | undefined;
-declare function maybeQueueFileTypeCheck(value: File, types: FileType[], message: string): void;
+declare function maybeQueueFileTypeCheck(value: File, types: FileType[], message: string, budget: FileTypeBudget): void;
 declare function matchesAnyFileType(mime: string, types: FileType[]): boolean;
 declare function checkFileExtension(type: string, extension: string): boolean;
 declare function parseFileUnit(size: FileUnit): number;
 //#endregion
-export { ASYNC_REFINE, FileTypeDetector, PendingFileTypeCheck, checkFileExtension, collectFileTypeChecks, fileType, isAsyncPredicate, matchesAnyFileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks };
+export { ASYNC_REFINE, FileTypeBudget, FileTypeDetector, MAX_QUEUED_FILE_TYPE_CHECKS, PendingFileTypeCheck, checkFileExtension, collectFileTypeChecks, fileType, isAsyncPredicate, matchesAnyFileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks };

package/dist/type/elysia/file-type.js

@@ -33,11 +33,14 @@ async function fileType(file, type) {
 	return false;
 }
 let collecting = false;
+let collectEpoch = 0;
 let pendingFileTypeChecks;
+const MAX_QUEUED_FILE_TYPE_CHECKS = 64;
 const ASYNC_REFINE = "~elyAsyncRefine";
-const isAsyncPredicate = (v) => Array.isArray(v) ? v.some((x) => typeof x.check === "function" ? require_compile_utils.isAsyncFunction(x.check) || x.check["~elyAsyncRefine"] === true : false) : false;
+const isAsyncPredicate = (v) => Array.isArray(v) ? v.some(isAsyncPredicate) : typeof v?.check === "function" && (require_compile_utils.isAsyncFunction(v.check) || v.check["~elyAsyncRefine"] === true);
 function collectFileTypeChecks() {
 	collecting = true;
+	collectEpoch++;
 }
 function takeFileTypeChecks() {
 	collecting = false;
@@ -45,8 +48,19 @@ function takeFileTypeChecks() {
 	pendingFileTypeChecks = void 0;
 	return pending;
 }
-function maybeQueueFileTypeCheck(value, types, message) {
+function maybeQueueFileTypeCheck(value, types, message, budget) {
 	if (!collecting) return;
+	if (budget.epoch !== collectEpoch) {
+		budget.epoch = collectEpoch;
+		budget.count = 0;
+	}
+	if (budget.count++ >= budget.limit) {
+		if (budget.count === budget.limit + 1) (pendingFileTypeChecks ??= []).push({
+			file: value,
+			check: Promise.resolve(`Expect at most ${budget.limit} files`)
+		});
+		return;
+	}
 	if (!fileTypeDetectors) {
 		if (!require_universal_is_production.isProduction() && !warnedMissingDetector) warnMissingFileTypeDetector();
 		(pendingFileTypeChecks ??= []).push({
@@ -80,6 +94,7 @@ function parseFileUnit(size) {
 
 //#endregion
 exports.ASYNC_REFINE = ASYNC_REFINE;
+exports.MAX_QUEUED_FILE_TYPE_CHECKS = MAX_QUEUED_FILE_TYPE_CHECKS;
 exports.checkFileExtension = checkFileExtension;
 exports.collectFileTypeChecks = collectFileTypeChecks;
 exports.fileType = fileType;

package/dist/type/elysia/file-type.mjs

@@ -32,11 +32,14 @@ async function fileType(file, type) {
 	return false;
 }
 let collecting = false;
+let collectEpoch = 0;
 let pendingFileTypeChecks;
+const MAX_QUEUED_FILE_TYPE_CHECKS = 64;
 const ASYNC_REFINE = "~elyAsyncRefine";
-const isAsyncPredicate = (v) => Array.isArray(v) ? v.some((x) => typeof x.check === "function" ? isAsyncFunction(x.check) || x.check["~elyAsyncRefine"] === true : false) : false;
+const isAsyncPredicate = (v) => Array.isArray(v) ? v.some(isAsyncPredicate) : typeof v?.check === "function" && (isAsyncFunction(v.check) || v.check["~elyAsyncRefine"] === true);
 function collectFileTypeChecks() {
 	collecting = true;
+	collectEpoch++;
 }
 function takeFileTypeChecks() {
 	collecting = false;
@@ -44,8 +47,19 @@ function takeFileTypeChecks() {
 	pendingFileTypeChecks = void 0;
 	return pending;
 }
-function maybeQueueFileTypeCheck(value, types, message) {
+function maybeQueueFileTypeCheck(value, types, message, budget) {
 	if (!collecting) return;
+	if (budget.epoch !== collectEpoch) {
+		budget.epoch = collectEpoch;
+		budget.count = 0;
+	}
+	if (budget.count++ >= budget.limit) {
+		if (budget.count === budget.limit + 1) (pendingFileTypeChecks ??= []).push({
+			file: value,
+			check: Promise.resolve(`Expect at most ${budget.limit} files`)
+		});
+		return;
+	}
 	if (!fileTypeDetectors) {
 		if (!isProduction() && !warnedMissingDetector) warnMissingFileTypeDetector();
 		(pendingFileTypeChecks ??= []).push({
@@ -78,4 +92,4 @@ function parseFileUnit(size) {
 }
 
 //#endregion
-export { ASYNC_REFINE, checkFileExtension, collectFileTypeChecks, fileType, isAsyncPredicate, matchesAnyFileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks };
+export { ASYNC_REFINE, MAX_QUEUED_FILE_TYPE_CHECKS, checkFileExtension, collectFileTypeChecks, fileType, isAsyncPredicate, matchesAnyFileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks };

package/dist/type/elysia/file.d.ts

@@ -1,9 +1,7 @@
 import { FileOptions } from "../types.js";
-import { ASYNC_REFINE, FileTypeDetector, PendingFileTypeCheck, checkFileExtension, collectFileTypeChecks, fileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks } from "./file-type.js";
 import { Type } from "typebox";
 
 //#region src/type/elysia/file.d.ts
-declare let BaseFile: Type.TRefine<Type.TUnsafe<File>>;
 declare function File(options?: FileOptions): Readonly<Type.TRefine<Type.TUnsafe<File>>>;
 //#endregion
-export { ASYNC_REFINE, BaseFile, File, type FileTypeDetector, type PendingFileTypeCheck, checkFileExtension, collectFileTypeChecks, fileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks };
+export { File };

package/dist/type/elysia/file.js

@@ -1,17 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
-const require_type_elysia_file_type = require('./file-type.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
+const require_type_elysia_file_type = require('./file-type.js');
 
 //#region src/type/elysia/file.ts
 let BaseFile;
 let emptyFile;
 let sharedFile;
 function File(options) {
-	BaseFile ??= (0, typebox_type.Refine)((0, typebox_type.Unsafe)({ "~kind": "File" }), require_utils.isBlob, () => "must be instance of Blob");
+	BaseFile ??= require_type_typebox_type.Refine(require_type_typebox_type.Unsafe({ "~kind": "File" }), require_utils.isBlob, () => "must be instance of Blob");
 	if (!options || require_utils.isEmpty(options)) return emptyFile ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.File, require_type_elysia_utils.cloneSchema(BaseFile)));
 	sharedFile ??= require_type_elysia_utils.createSharedReference(FileWithProperty);
 	return sharedFile(options);
@@ -29,36 +28,21 @@ function FileWithProperty(options) {
 	if (options.type) {
 		const types = typeof options.type === "string" ? [options.type] : options.type;
 		const message = types.length === 1 ? `Expect file type to be ${types[0]}` : `Expect file type to be one of ${types.join(", ")}`;
+		const budget = {
+			epoch: -1,
+			count: 0,
+			limit: options.maxItems ?? 64
+		};
 		const checkType = (value) => {
 			if (!require_type_elysia_file_type.matchesAnyFileType(value.type, types)) return false;
-			require_type_elysia_file_type.maybeQueueFileTypeCheck(value, types, message);
+			require_type_elysia_file_type.maybeQueueFileTypeCheck(value, types, message, budget);
 			return true;
 		};
 		checkType[require_type_elysia_file_type.ASYNC_REFINE] = true;
 		refines.push([checkType, message]);
 	}
-	let schema = require_type_elysia_utils.Refines(BaseFile, refines);
-	const [, meta] = require_type_elysia_utils.getMeta(options);
-	if (meta) {
-		schema = require_type_elysia_utils.cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.File, schema);
+	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.File, require_type_elysia_utils.withMeta(require_type_elysia_utils.Refines(BaseFile, refines), options));
 }
 
 //#endregion
-exports.ASYNC_REFINE = require_type_elysia_file_type.ASYNC_REFINE;
-Object.defineProperty(exports, 'BaseFile', {
-  enumerable: true,
-  get: function () {
-    return BaseFile;
-  }
-});
-exports.File = File;
-exports.checkFileExtension = require_type_elysia_file_type.checkFileExtension;
-exports.collectFileTypeChecks = require_type_elysia_file_type.collectFileTypeChecks;
-exports.fileType = require_type_elysia_file_type.fileType;
-exports.maybeQueueFileTypeCheck = require_type_elysia_file_type.maybeQueueFileTypeCheck;
-exports.parseFileUnit = require_type_elysia_file_type.parseFileUnit;
-exports.setFileTypeDetector = require_type_elysia_file_type.setFileTypeDetector;
-exports.takeFileTypeChecks = require_type_elysia_file_type.takeFileTypeChecks;
+exports.File = File;

package/dist/type/elysia/file.mjs

@@ -1,8 +1,8 @@
 import { isBlob, isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
-import { ASYNC_REFINE, checkFileExtension, collectFileTypeChecks, fileType, matchesAnyFileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks } from "./file-type.mjs";
-import { Refines, cloneSchema, createSharedReference, elyType, getMeta } from "./utils.mjs";
-import { Refine, Unsafe } from "typebox/type";
+import { Refine, Unsafe } from "../typebox-type.mjs";
+import { Refines, cloneSchema, createSharedReference, elyType, withMeta } from "./utils.mjs";
+import { ASYNC_REFINE, MAX_QUEUED_FILE_TYPE_CHECKS, matchesAnyFileType, maybeQueueFileTypeCheck, parseFileUnit } from "./file-type.mjs";
 
 //#region src/type/elysia/file.ts
 let BaseFile;
@@ -27,22 +27,21 @@ function FileWithProperty(options) {
 	if (options.type) {
 		const types = typeof options.type === "string" ? [options.type] : options.type;
 		const message = types.length === 1 ? `Expect file type to be ${types[0]}` : `Expect file type to be one of ${types.join(", ")}`;
+		const budget = {
+			epoch: -1,
+			count: 0,
+			limit: options.maxItems ?? 64
+		};
 		const checkType = (value) => {
 			if (!matchesAnyFileType(value.type, types)) return false;
-			maybeQueueFileTypeCheck(value, types, message);
+			maybeQueueFileTypeCheck(value, types, message, budget);
 			return true;
 		};
 		checkType[ASYNC_REFINE] = true;
 		refines.push([checkType, message]);
 	}
-	let schema = Refines(BaseFile, refines);
-	const [, meta] = getMeta(options);
-	if (meta) {
-		schema = cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return elyType(ELYSIA_TYPES.File, schema);
+	return elyType(ELYSIA_TYPES.File, withMeta(Refines(BaseFile, refines), options));
 }
 
 //#endregion
-export { ASYNC_REFINE, BaseFile, File, checkFileExtension, collectFileTypeChecks, fileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks };
+export { File };

package/dist/type/elysia/files.js

@@ -1,18 +1,17 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_array = require('./array.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
 const require_type_elysia_file = require('./file.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/files.ts
 let BaseFiles;
 let emptyFiles;
 let sharedFiles;
-const filesUnion = (options) => require_type_elysia_union.Union([require_type_elysia_array.ArrayType(require_type_elysia_file.File(options)), (0, typebox_type.Decode)(require_type_elysia_file.File(options), (value) => [value])]);
+const filesUnion = (options) => require_type_elysia_union.Union([require_type_elysia_array.ArrayType(require_type_elysia_file.File(options)), require_type_typebox_type.Decode(require_type_elysia_file.File(options), (value) => [value])]);
 function Files(options) {
 	BaseFiles ??= filesUnion();
 	if (!options || require_utils.isEmpty(options)) return emptyFiles ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Files, require_type_elysia_utils.cloneSchema(BaseFiles)));
@@ -21,7 +20,10 @@ function Files(options) {
 }
 function FilesWithProperty(options) {
 	const fileOptions = {};
-	if (options.type !== void 0) fileOptions.type = options.type;
+	if (options.type !== void 0) {
+		fileOptions.type = options.type;
+		if (options.maxItems !== void 0) fileOptions.maxItems = options.maxItems;
+	}
 	if (options.minSize !== void 0) fileOptions.minSize = options.minSize;
 	if (options.maxSize !== void 0) fileOptions.maxSize = options.maxSize;
 	const base = require_utils.isEmpty(fileOptions) ? BaseFiles : filesUnion(fileOptions);
@@ -32,13 +34,7 @@ function FilesWithProperty(options) {
 	if (options.maxItems !== void 0) refines.push([(value) => {
 		return (Array.isArray(value) ? value.length : require_utils.isBlob(value) ? 1 : 0) <= options.maxItems;
 	}, `Expect less than ${options.maxItems} files`]);
-	let schema = require_type_elysia_utils.Refines(base, refines);
-	const [, meta] = require_type_elysia_utils.getMeta(options);
-	if (meta) {
-		schema = require_type_elysia_utils.cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Files, schema);
+	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Files, require_type_elysia_utils.withMeta(require_type_elysia_utils.Refines(base, refines), options));
 }
 
 //#endregion

package/dist/type/elysia/files.mjs

@@ -1,10 +1,10 @@
 import { isBlob, isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Decode } from "../typebox-type.mjs";
 import { ArrayType } from "./array.mjs";
 import { Union } from "./union.mjs";
-import { Refines, cloneSchema, createSharedReference, elyType, getMeta } from "./utils.mjs";
+import { Refines, cloneSchema, createSharedReference, elyType, withMeta } from "./utils.mjs";
 import { File } from "./file.mjs";
-import { Decode } from "typebox/type";
 
 //#region src/type/elysia/files.ts
 let BaseFiles;
@@ -19,7 +19,10 @@ function Files(options) {
 }
 function FilesWithProperty(options) {
 	const fileOptions = {};
-	if (options.type !== void 0) fileOptions.type = options.type;
+	if (options.type !== void 0) {
+		fileOptions.type = options.type;
+		if (options.maxItems !== void 0) fileOptions.maxItems = options.maxItems;
+	}
 	if (options.minSize !== void 0) fileOptions.minSize = options.minSize;
 	if (options.maxSize !== void 0) fileOptions.maxSize = options.maxSize;
 	const base = isEmpty(fileOptions) ? BaseFiles : filesUnion(fileOptions);
@@ -30,13 +33,7 @@ function FilesWithProperty(options) {
 	if (options.maxItems !== void 0) refines.push([(value) => {
 		return (Array.isArray(value) ? value.length : isBlob(value) ? 1 : 0) <= options.maxItems;
 	}, `Expect less than ${options.maxItems} files`]);
-	let schema = Refines(base, refines);
-	const [, meta] = getMeta(options);
-	if (meta) {
-		schema = cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return elyType(ELYSIA_TYPES.Files, schema);
+	return elyType(ELYSIA_TYPES.Files, withMeta(Refines(base, refines), options));
 }
 
 //#endregion

package/dist/type/elysia/form.js

@@ -1,16 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_utils = require('./utils.js');
 const require_type_elysia_object = require('./object.js');
 const require_type_elysia_intersect = require('./intersect.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/form.ts
 let BaseForm;
 const Form = (property, options) => {
-	BaseForm ??= Object.freeze((0, typebox_type.Decode)((0, typebox_type.Refine)((0, typebox_type.Unsafe)({ "~kind": "FormData" }), (value) => require_utils.isElysiaForm(value), () => "must be instance of Elysia.form"), (value) => value));
+	BaseForm ??= Object.freeze(require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_typebox_type.Unsafe({ "~kind": "FormData" }), (value) => require_utils.isElysiaForm(value), () => "must be instance of Elysia.form"), (value) => value));
 	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Form, require_type_elysia_intersect.Intersect([BaseForm, require_type_elysia_object.ObjectType(property, options)]));
 };
 

package/dist/type/elysia/form.mjs

@@ -1,15 +1,15 @@
 import { isElysiaForm } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Decode, Refine, Unsafe } from "../typebox-type.mjs";
 import { elyType } from "./utils.mjs";
 import { ObjectType } from "./object.mjs";
-import { Intersect as Intersect$1 } from "./intersect.mjs";
-import { Decode, Refine, Unsafe } from "typebox/type";
+import { Intersect } from "./intersect.mjs";
 
 //#region src/type/elysia/form.ts
 let BaseForm;
 const Form = (property, options) => {
 	BaseForm ??= Object.freeze(Decode(Refine(Unsafe({ "~kind": "FormData" }), (value) => isElysiaForm(value), () => "must be instance of Elysia.form"), (value) => value));
-	return elyType(ELYSIA_TYPES.Form, Intersect$1([BaseForm, ObjectType(property, options)]));
+	return elyType(ELYSIA_TYPES.Form, Intersect([BaseForm, ObjectType(property, options)]));
 };
 
 //#endregion

package/dist/type/elysia/integer-string.d.ts

@@ -2,6 +2,6 @@ import { TNumberOptions, Type } from "typebox";
 
 //#region src/type/elysia/integer-string.d.ts
 type IntegerStringSchema = Type.TUnion<[Type.TInteger, Type.TCodec<Type.TRefine<Type.TString>, number>]>;
-declare function IntegerString(property?: TNumberOptions): Readonly<IntegerStringSchema>;
+declare const IntegerString: (property?: TNumberOptions) => Readonly<IntegerStringSchema>;
 //#endregion
 export { IntegerString };

package/dist/type/elysia/integer-string.js

@@ -1,40 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
-const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
 const require_type_shared = require('../shared.js');
-const require_type_elysia_string = require('./string.js');
-const require_type_elysia_union = require('./union.js');
-const require_type_elysia_utils = require('./utils.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_number = require('./number.js');
+const require_type_elysia_numeric = require('./numeric.js');
 const require_type_elysia_integer = require('./integer.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/integer-string.ts
-let StringifiedInteger;
-let StrictInteger;
-let emptyIntegerString;
-function IntegerString(property) {
-	StringifiedInteger ??= require_type_shared.pureRefine((0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => /^[+-]?\d+$/.test(value) && Number.isInteger(+value), () => "must be integer"), (value) => +value));
-	StrictInteger ??= require_type_shared.pureRefine((0, typebox_type.Refine)(require_type_elysia_number.NumberType(), (value) => Number.isInteger(value), () => "must be integer"));
-	if (!property || require_utils.isEmpty(property)) return emptyIntegerString ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Integer, require_type_elysia_union.Union([StrictInteger, StringifiedInteger])));
-	const [constraints, meta] = require_type_elysia_utils.getMeta(property);
-	const integer = require_type_elysia_integer.Integer(constraints);
-	const c = constraints;
-	const stringified = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
-		if (!/^[+-]?\d+$/.test(value)) return false;
-		const n = +value;
-		if (!Number.isInteger(n)) return false;
-		if (typeof c.minimum === "number" && n < c.minimum) return false;
-		if (typeof c.maximum === "number" && n > c.maximum) return false;
-		if (typeof c.exclusiveMinimum === "number" && n <= c.exclusiveMinimum) return false;
-		if (typeof c.exclusiveMaximum === "number" && n >= c.exclusiveMaximum) return false;
-		if (typeof c.multipleOf === "number" && n % c.multipleOf !== 0) return false;
-		return true;
-	}, () => "must be integer"), (value) => +value);
-	require_type_shared.pureRefine(stringified);
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Integer, require_type_elysia_union.Union([integer, stringified], meta));
-}
+const integerString = /* @__PURE__ */ require_type_elysia_numeric.numericString(require_type_constants.ELYSIA_TYPES.Integer, "must be integer", (value) => /^[+-]?\d+$/.test(value) && (value.length < 309 || Number.isInteger(+value)), require_type_elysia_integer.Integer, () => require_type_shared.pureRefine(require_type_typebox_type.Refine(require_type_elysia_number.NumberType(), (value) => Number.isInteger(value), () => "must be integer")));
+const IntegerString = (property) => integerString(property);
 
 //#endregion
 exports.IntegerString = IntegerString;

package/dist/type/elysia/integer-string.mjs

@@ -1,38 +1,13 @@
-import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { pureRefine } from "../shared.mjs";
-import { StringType } from "./string.mjs";
-import { Union } from "./union.mjs";
-import { elyType, getMeta } from "./utils.mjs";
+import { Refine } from "../typebox-type.mjs";
 import { NumberType } from "./number.mjs";
-import { Integer as Integer$1 } from "./integer.mjs";
-import { Decode, Refine } from "typebox/type";
+import { numericString } from "./numeric.mjs";
+import { Integer } from "./integer.mjs";
 
 //#region src/type/elysia/integer-string.ts
-let StringifiedInteger;
-let StrictInteger;
-let emptyIntegerString;
-function IntegerString(property) {
-	StringifiedInteger ??= pureRefine(Decode(Refine(StringType(), (value) => /^[+-]?\d+$/.test(value) && Number.isInteger(+value), () => "must be integer"), (value) => +value));
-	StrictInteger ??= pureRefine(Refine(NumberType(), (value) => Number.isInteger(value), () => "must be integer"));
-	if (!property || isEmpty(property)) return emptyIntegerString ??= Object.freeze(elyType(ELYSIA_TYPES.Integer, Union([StrictInteger, StringifiedInteger])));
-	const [constraints, meta] = getMeta(property);
-	const integer = Integer$1(constraints);
-	const c = constraints;
-	const stringified = Decode(Refine(StringType(), (value) => {
-		if (!/^[+-]?\d+$/.test(value)) return false;
-		const n = +value;
-		if (!Number.isInteger(n)) return false;
-		if (typeof c.minimum === "number" && n < c.minimum) return false;
-		if (typeof c.maximum === "number" && n > c.maximum) return false;
-		if (typeof c.exclusiveMinimum === "number" && n <= c.exclusiveMinimum) return false;
-		if (typeof c.exclusiveMaximum === "number" && n >= c.exclusiveMaximum) return false;
-		if (typeof c.multipleOf === "number" && n % c.multipleOf !== 0) return false;
-		return true;
-	}, () => "must be integer"), (value) => +value);
-	pureRefine(stringified);
-	return elyType(ELYSIA_TYPES.Integer, Union([integer, stringified], meta));
-}
+const integerString = /* @__PURE__ */ numericString(ELYSIA_TYPES.Integer, "must be integer", (value) => /^[+-]?\d+$/.test(value) && (value.length < 309 || Number.isInteger(+value)), Integer, () => pureRefine(Refine(NumberType(), (value) => Number.isInteger(value), () => "must be integer")));
+const IntegerString = (property) => integerString(property);
 
 //#endregion
 export { IntegerString };

package/dist/type/elysia/integer.js

@@ -1,19 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
-const require_utils = require('../../utils.js');
-const require_type_constants = require('../constants.js');
-let typebox_type = require("typebox/type");
+const require_type_elysia_number = require('./number.js');
 
 //#region src/type/elysia/integer.ts
-const emptyInteger = Object.freeze((0, typebox_type.Integer)());
+const integer = /* @__PURE__ */ require_type_elysia_number.primitive("integer", "Integer");
 function Integer(options) {
-	if (!options || require_utils.isEmpty(options)) return emptyInteger;
-	const schema = {
-		...options,
-		type: "integer",
-		"~kind": "Integer"
-	};
-	return Object.defineProperty(schema, "~kind", require_type_constants.noEnumerable);
+	return integer(options);
 }
 
 //#endregion

package/dist/type/elysia/integer.mjs

@@ -1,17 +1,9 @@
-import { isEmpty } from "../../utils.mjs";
-import { noEnumerable } from "../constants.mjs";
-import { Integer as Integer$1 } from "typebox/type";
+import { primitive } from "./number.mjs";
 
 //#region src/type/elysia/integer.ts
-const emptyInteger = Object.freeze(Integer$1());
+const integer = /* @__PURE__ */ primitive("integer", "Integer");
 function Integer(options) {
-	if (!options || isEmpty(options)) return emptyInteger;
-	const schema = {
-		...options,
-		type: "integer",
-		"~kind": "Integer"
-	};
-	return Object.defineProperty(schema, "~kind", noEnumerable);
+	return integer(options);
 }
 
 //#endregion

package/dist/type/elysia/intersect.js

@@ -1,13 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_utils = require('../../utils.js');
 const require_type_constants = require('../constants.js');
 
 //#region src/type/elysia/intersect.ts
 function Intersect(schemas, options) {
-	if (!options || require_utils.isEmpty(options)) return Object.defineProperty({
-		"~kind": "Intersect",
-		allOf: schemas
-	}, "~kind", require_type_constants.noEnumerable);
 	const schema = {
 		...options,
 		"~kind": "Intersect",

package/dist/type/elysia/intersect.mjs

@@ -1,12 +1,7 @@
-import { isEmpty } from "../../utils.mjs";
 import { noEnumerable } from "../constants.mjs";
 
 //#region src/type/elysia/intersect.ts
 function Intersect(schemas, options) {
-	if (!options || isEmpty(options)) return Object.defineProperty({
-		"~kind": "Intersect",
-		allOf: schemas
-	}, "~kind", noEnumerable);
 	const schema = {
 		...options,
 		"~kind": "Intersect",

package/dist/type/elysia/json-string.d.ts

@@ -0,0 +1,7 @@
+import * as _$typebox from "typebox";
+import { TSchema } from "typebox";
+
+//#region src/type/elysia/json-string.d.ts
+declare function jsonString<T extends TSchema>(inner: T, open: number, message: string): _$typebox.TCodec<_$typebox.TRefine<_$typebox.TString>, _$typebox.StaticType<[], "Decode", {}, {}, T>>;
+//#endregion
+export { jsonString };