elysia 2.0.0-beta.2 → 2.0.0-beta.3

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

@@ -1,11 +1,11 @@
 import { nullObject } from "../../utils.mjs";
-import { Check, Compile, Decode as Decode$1 } from "../bridge.mjs";
+import { Check, Compile, Decode } from "../bridge.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Decode as Decode$1, Refine } from "../typebox-type.mjs";
 import { ArrayType } from "./array.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { elyType, getMeta } from "./utils.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/array-string.ts
 const MEMO_LIMIT = 8192;
@@ -26,25 +26,29 @@ function ArrayString(property, _options) {
 	};
 	let raw;
 	let parsed;
-	const arrayString = Decode(Refine(StringType(), (value) => {
+	const arrayString = Decode$1(Refine(StringType(), (value) => {
 		if (value.charCodeAt(0) !== 91) return false;
 		if (value === raw) return true;
 		try {
 			const next = JSON.parse(value);
-			if (!checkInner(next)) return false;
+			if (!checkInner(next)) {
+				raw = parsed = void 0;
+				return false;
+			}
 			if (value.length <= MEMO_LIMIT) {
 				raw = value;
 				parsed = next;
 			}
 			return true;
 		} catch {
+			raw = parsed = void 0;
 			return false;
 		}
 	}, () => "must be an array"), (value) => {
 		const decoded = value === raw ? parsed : JSON.parse(value);
 		raw = void 0;
 		parsed = void 0;
-		return Decode$1(array, decoded);
+		return Decode(array, decoded);
 	});
 	return elyType(ELYSIA_TYPES.ArrayString, Union([array, arrayString], meta));
 }

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

@@ -1,19 +1,18 @@
 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_typebox_type = require('../typebox-type.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_elysia_boolean = require('./boolean.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/boolean-string.ts
 let StringifiedBoolean;
 let emptyBooleanString;
 function BooleanString(property) {
-	StringifiedBoolean ??= require_type_shared.pureRefine((0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => value === "true" || value === "false", () => "must be boolean"), (value) => value === "true" ? true : false));
+	StringifiedBoolean ??= require_type_shared.pureRefine(require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), (value) => value === "true" || value === "false", () => "must be boolean"), (value) => value === "true" ? true : false));
 	if (!property || require_utils.isEmpty(property)) return emptyBooleanString ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.BooleanString, require_type_elysia_union.Union([require_type_elysia_boolean.BooleanType(), StringifiedBoolean])));
 	const [, meta] = require_type_elysia_utils.getMeta(property);
 	const boolean = require_type_elysia_boolean.BooleanType(property);

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

@@ -1,11 +1,11 @@
 import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { pureRefine } from "../shared.mjs";
+import { Decode, Refine } from "../typebox-type.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { elyType, getMeta } from "./utils.mjs";
 import { BooleanType } from "./boolean.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/boolean-string.ts
 let StringifiedBoolean;

package/dist/type/elysia/boolean.js

@@ -1,11 +1,12 @@
 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");
 
 //#region src/type/elysia/boolean.ts
-const emptyBoolean = Object.freeze((0, typebox_type.Boolean)());
+const emptyBoolean = Object.freeze(Object.defineProperty({
+	type: "boolean",
+	"~kind": "Boolean"
+}, "~kind", require_type_constants.noEnumerable));
 function BooleanType(options) {
 	if (!options || require_utils.isEmpty(options)) return emptyBoolean;
 	const schema = {

package/dist/type/elysia/boolean.mjs

@@ -1,9 +1,11 @@
 import { isEmpty } from "../../utils.mjs";
 import { noEnumerable } from "../constants.mjs";
-import { Boolean } from "typebox/type";
 
 //#region src/type/elysia/boolean.ts
-const emptyBoolean = Object.freeze(Boolean());
+const emptyBoolean = Object.freeze(Object.defineProperty({
+	type: "boolean",
+	"~kind": "Boolean"
+}, "~kind", noEnumerable));
 function BooleanType(options) {
 	if (!options || isEmpty(options)) return emptyBoolean;
 	const schema = {

package/dist/type/elysia/cookie.js

@@ -13,7 +13,8 @@ const COOKIE_OPTION_KEYS = [
 	"secure",
 	"partitioned",
 	"secrets",
-	"sign"
+	"sign",
+	"legacySignature"
 ];
 function extractConfig(options) {
 	if (!options) return {

package/dist/type/elysia/cookie.mjs

@@ -12,7 +12,8 @@ const COOKIE_OPTION_KEYS = [
 	"secure",
 	"partitioned",
 	"secrets",
-	"sign"
+	"sign",
+	"legacySignature"
 ];
 function extractConfig(options) {
 	if (!options) return {

package/dist/type/elysia/date.js

@@ -1,11 +1,11 @@
 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_string = require('./string.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
+const require_type_elysia_number = require('./number.js');
 
 //#region src/type/elysia/date.ts
 const ISO8601 = /T\d\d(?::\d\d){1,2} \d\d:\d\d$/;
@@ -20,14 +20,14 @@ let StringifiedDate;
 let emptyDate;
 let sharedDate;
 function DateType(property) {
-	StringifiedDate ??= (0, typebox_type.Codec)(require_type_elysia_union.Union([
-		(0, typebox_type.Refine)((0, typebox_type.Unsafe)({ "~kind": "Date" }), (value) => value instanceof Date, () => "must be Date"),
-		(0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
+	StringifiedDate ??= require_type_typebox_type.Codec(require_type_elysia_union.Union([
+		require_type_typebox_type.Refine(require_type_typebox_type.Unsafe({ "~kind": "Date" }), (value) => value instanceof Date, () => "must be Date"),
+		require_type_typebox_type.Refine(require_type_elysia_string.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"),
-		(0, typebox_type.Number)()
+		require_type_elysia_number.NumberType()
 	])).Decode((value) => {
 		if (value instanceof Date) return value;
 		let d = new Date(value);
@@ -56,7 +56,7 @@ function DateWithProperty(options) {
 	let schema = StringifiedDate;
 	if (minMessage || maxMessage || xMinMessage || xMaxMessage || stepMessage) {
 		let failed = "must be Date";
-		schema = (0, typebox_type.Refine)(schema, (value) => {
+		schema = require_type_typebox_type.Refine(schema, (value) => {
 			const t = toTimestamp(value);
 			if (minMessage && t < min) {
 				failed = minMessage;

package/dist/type/elysia/date.mjs

@@ -1,9 +1,10 @@
 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$/;
@@ -25,7 +26,7 @@ function DateType(property) {
 			if (ISO8601.test(value)) return !isNaN(new Date(value.replace(removeTime, "+$1")).getTime());
 			return false;
 		}, () => "must be Date"),
-		Number()
+		NumberType()
 	])).Decode((value) => {
 		if (value instanceof Date) return value;
 		let d = new Date(value);

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

@@ -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 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;
 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;
 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.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");
 
 //#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,9 +28,14 @@ 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;

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 { ASYNC_REFINE, MAX_QUEUED_FILE_TYPE_CHECKS, checkFileExtension, collectFileTypeChecks, fileType, matchesAnyFileType, maybeQueueFileTypeCheck, parseFileUnit, setFileTypeDetector, takeFileTypeChecks } from "./file-type.mjs";
+import { Refine, Unsafe } from "../typebox-type.mjs";
 import { Refines, cloneSchema, createSharedReference, elyType, getMeta } from "./utils.mjs";
-import { Refine, Unsafe } from "typebox/type";
 
 //#region src/type/elysia/file.ts
 let BaseFile;
@@ -27,9 +27,14 @@ 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;

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);

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 { 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);

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.js

@@ -1,27 +1,26 @@
 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_typebox_type = require('../typebox-type.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_elysia_number = require('./number.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"));
+	StringifiedInteger ??= require_type_shared.pureRefine(require_type_typebox_type.Decode(require_type_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(require_type_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) => {
+	const stringified = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), (value) => {
 		if (!/^[+-]?\d+$/.test(value)) return false;
 		const n = +value;
 		if (!Number.isInteger(n)) return false;

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

@@ -1,12 +1,12 @@
 import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { pureRefine } from "../shared.mjs";
+import { Decode, Refine } from "../typebox-type.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { elyType, getMeta } from "./utils.mjs";
 import { NumberType } from "./number.mjs";
-import { Integer as Integer$1 } from "./integer.mjs";
-import { Decode, Refine } from "typebox/type";
+import { Integer } from "./integer.mjs";
 
 //#region src/type/elysia/integer-string.ts
 let StringifiedInteger;
@@ -17,7 +17,7 @@ function IntegerString(property) {
 	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 integer = Integer(constraints);
 	const c = constraints;
 	const stringified = Decode(Refine(StringType(), (value) => {
 		if (!/^[+-]?\d+$/.test(value)) return false;

package/dist/type/elysia/integer.js

@@ -1,11 +1,12 @@
 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");
 
 //#region src/type/elysia/integer.ts
-const emptyInteger = Object.freeze((0, typebox_type.Integer)());
+const emptyInteger = Object.freeze(Object.defineProperty({
+	type: "integer",
+	"~kind": "Integer"
+}, "~kind", require_type_constants.noEnumerable));
 function Integer(options) {
 	if (!options || require_utils.isEmpty(options)) return emptyInteger;
 	const schema = {

package/dist/type/elysia/integer.mjs

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

package/dist/type/elysia/maybe-empty.js

@@ -1,16 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/maybe-empty.ts
 function MaybeEmpty(schema, options) {
 	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.MaybeEmpty, require_type_elysia_union.Union([
 		schema,
-		(0, typebox_type.Null)(),
-		(0, typebox_type.Undefined)()
+		require_type_typebox_type.Null(),
+		require_type_typebox_type.Undefined()
 	], {
 		...options,
 		nullable: true

package/dist/type/elysia/maybe-empty.mjs

@@ -1,7 +1,7 @@
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Null, Undefined } from "../typebox-type.mjs";
 import { Union } from "./union.mjs";
 import { elyType } from "./utils.mjs";
-import { Null, Undefined } from "typebox/type";
 
 //#region src/type/elysia/maybe-empty.ts
 function MaybeEmpty(schema, options) {

package/dist/type/elysia/nullable.js

@@ -1,12 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.js');
 const require_type_constants = require('../constants.js');
+const require_type_typebox_type = require('../typebox-type.js');
 const require_type_elysia_union = require('./union.js');
 const require_type_elysia_utils = require('./utils.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/nullable.ts
-const Nullable = (schema, options) => require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Nullable, require_type_elysia_union.Union([schema, (0, typebox_type.Null)()], {
+const Nullable = (schema, options) => require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Nullable, require_type_elysia_union.Union([schema, require_type_typebox_type.Null()], {
 	...options,
 	nullable: true
 }));

package/dist/type/elysia/nullable.mjs

@@ -1,7 +1,7 @@
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Null } from "../typebox-type.mjs";
 import { Union } from "./union.mjs";
 import { elyType } from "./utils.mjs";
-import { Null } from "typebox/type";
 
 //#region src/type/elysia/nullable.ts
 const Nullable = (schema, options) => elyType(ELYSIA_TYPES.Nullable, Union([schema, Null()], {

package/dist/type/elysia/number.js

@@ -1,11 +1,12 @@
 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");
 
 //#region src/type/elysia/number.ts
-const emptyNumber = Object.freeze((0, typebox_type.Number)());
+const emptyNumber = Object.freeze(Object.defineProperty({
+	type: "number",
+	"~kind": "Number"
+}, "~kind", require_type_constants.noEnumerable));
 function NumberType(options) {
 	if (!options || require_utils.isEmpty(options)) return emptyNumber;
 	const schema = {