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

package/dist/type/compat.js

@@ -1,28 +1,36 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_type_bridge = require('./bridge.js');
 const require_type_utils = require('./utils.js');
+const require_type_typebox_type = require('./typebox-type.js');
+const require_type_typebox_value = require('./typebox-value.js');
 const require_type_coerce = require('./coerce.js');
 const require_type_validator_exact_mirror = require('./validator/exact-mirror.js');
 const require_type_validator_validator_cache = require('./validator/validator-cache.js');
 const require_type_validator_index = require('./validator/index.js');
 const require_type_elysia_intersect = require('./elysia/intersect.js');
-let typebox_type = require("typebox/type");
-let typebox_compile = require("typebox/compile");
-let typebox_value = require("typebox/value");
-let typebox_system = require("typebox/system");
 
 //#region src/type/compat.ts
 let setup = false;
 function setupTypebox(options) {
 	if (options?.exactMirror) require_type_validator_exact_mirror.setExactMirror(options.exactMirror);
+	const typebox = options?.typebox;
+	if (typebox) {
+		if (!typebox.type !== !typebox.system) throw new Error(`setupTypebox({ typebox }) received an incomplete type-side namespace (only '${typebox.type ? "type" : "system"}' was set). 'type' and 'system' must be provided together.`);
+		const missing = [
+			"value",
+			"schema",
+			"compile"
+		].filter((key) => !typebox[key]);
+		if (missing.length === 1 || missing.length === 2) throw new Error(`setupTypebox({ typebox }) received an incomplete value-side namespace (missing '${missing.join("', '")}'). 'value', 'schema', and 'compile' must be provided together.`);
+		if (typebox.type && typebox.system) require_type_typebox_type.injectTypeboxType(typebox);
+		if (typebox.value && typebox.schema && typebox.compile) require_type_typebox_value.injectTypebox(typebox);
+	}
 	if (setup) return;
 	setup = true;
-	typebox_system.Settings.Set({ unionPrioritySort: false });
 	require_type_bridge.useTypebox({
-		Compile: typebox_compile.Compile,
-		Create: typebox_value.Create,
-		Decode: typebox_value.Decode,
+		Compile: require_type_typebox_value.Compile,
+		Create: require_type_typebox_value.Create,
+		Decode: require_type_typebox_value.Decode,
 		applyCoercions: require_type_coerce.applyCoercions,
 		TypeBoxValidator: require_type_validator_index.TypeBoxValidator,
 		TypeBoxValidatorCache: require_type_validator_validator_cache.TypeBoxValidatorCache,
@@ -33,12 +41,13 @@ function setupTypebox(options) {
 		coerceBody: require_type_coerce.coerceBody,
 		hasTypes: require_type_utils.hasTypes,
 		mayHaveFileType: require_type_validator_validator_cache.mayHaveFileType,
-		HasCodec: typebox_value.HasCodec,
+		HasCodec: require_type_typebox_value.HasCodec,
 		Intersect: require_type_elysia_intersect.Intersect,
-		Default: typebox_value.Default,
-		Ref: typebox_type.Ref,
-		Clone: typebox_value.Clone,
-		Check: typebox_value.Check
+		Ref: require_type_typebox_type.Ref,
+		Clone: require_type_typebox_value.Clone,
+		Check: require_type_typebox_value.Check,
+		warmTypebox: require_type_typebox_value.warmTypebox,
+		preloadTypebox: require_type_typebox_value.preloadTypebox
 	});
 }
 

package/dist/type/compat.mjs

@@ -1,26 +1,35 @@
 import { useTypebox } from "./bridge.mjs";
 import { hasTypes } from "./utils.mjs";
+import { Ref, injectTypeboxType } from "./typebox-type.mjs";
+import { Check, Clone, Compile, Create, Decode, HasCodec, injectTypebox, preloadTypebox, warmTypebox as load } from "./typebox-value.mjs";
 import { applyCoercions, coerceBody, coerceFormData, coerceQuery, coerceRoot, coerceStringToStructure } from "./coerce.mjs";
 import { setExactMirror } from "./validator/exact-mirror.mjs";
 import { TypeBoxValidatorCache, mayHaveFileType } from "./validator/validator-cache.mjs";
 import { TypeBoxValidator } from "./validator/index.mjs";
-import { Intersect as Intersect$1 } from "./elysia/intersect.mjs";
-import { Ref } from "typebox/type";
-import { Compile } from "typebox/compile";
-import { Check, Clone, Create, Decode as Decode$1, Default, HasCodec } from "typebox/value";
-import { Settings } from "typebox/system";
+import { Intersect } from "./elysia/intersect.mjs";
 
 //#region src/type/compat.ts
 let setup = false;
 function setupTypebox(options) {
 	if (options?.exactMirror) setExactMirror(options.exactMirror);
+	const typebox = options?.typebox;
+	if (typebox) {
+		if (!typebox.type !== !typebox.system) throw new Error(`setupTypebox({ typebox }) received an incomplete type-side namespace (only '${typebox.type ? "type" : "system"}' was set). 'type' and 'system' must be provided together.`);
+		const missing = [
+			"value",
+			"schema",
+			"compile"
+		].filter((key) => !typebox[key]);
+		if (missing.length === 1 || missing.length === 2) throw new Error(`setupTypebox({ typebox }) received an incomplete value-side namespace (missing '${missing.join("', '")}'). 'value', 'schema', and 'compile' must be provided together.`);
+		if (typebox.type && typebox.system) injectTypeboxType(typebox);
+		if (typebox.value && typebox.schema && typebox.compile) injectTypebox(typebox);
+	}
 	if (setup) return;
 	setup = true;
-	Settings.Set({ unionPrioritySort: false });
 	useTypebox({
 		Compile,
 		Create,
-		Decode: Decode$1,
+		Decode,
 		applyCoercions,
 		TypeBoxValidator,
 		TypeBoxValidatorCache,
@@ -32,11 +41,12 @@ function setupTypebox(options) {
 		hasTypes,
 		mayHaveFileType,
 		HasCodec,
-		Intersect: Intersect$1,
-		Default,
+		Intersect,
 		Ref,
 		Clone,
-		Check
+		Check,
+		warmTypebox: load,
+		preloadTypebox
 	});
 }
 

package/dist/type/elysia/array-buffer.d.ts

@@ -1,6 +1,9 @@
+import { ELYSIA_TYPES } from "../constants.js";
 import { ArrayBufferOptions } from "../types.js";
+import { TSchema } from "typebox";
 
 //#region src/type/elysia/array-buffer.d.ts
+declare function bufferType(tag: ELYSIA_TYPES[keyof ELYSIA_TYPES], base: () => TSchema): (property?: ArrayBufferOptions) => any;
 declare function ArrayBufferType(property?: ArrayBufferOptions): any;
 //#endregion
-export { ArrayBufferType };
+export { ArrayBufferType, bufferType };

package/dist/type/elysia/array-buffer.js

@@ -1,27 +1,27 @@
 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');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/array-buffer.ts
-let BaseArrayBuffer;
-let emptyArrayBuffer;
+function bufferType(tag, base) {
+	let Base;
+	let empty;
+	return (property) => {
+		Base ??= base();
+		if (!property || require_utils.isEmpty(property)) return empty ??= Object.freeze(require_type_elysia_utils.elyType(tag, Base));
+		const refines = [];
+		if (property.minByteLength !== void 0) refines.push([(value) => value.byteLength >= property.minByteLength, `Expect byte to be more than ${property.minByteLength}`]);
+		if (property.maxByteLength !== void 0) refines.push([(value) => value.byteLength <= property.maxByteLength, `Expect byte to be less than ${property.maxByteLength}`]);
+		return require_type_elysia_utils.elyType(tag, require_type_elysia_utils.withMeta(require_type_elysia_utils.Refines(Base, refines), property));
+	};
+}
+const arrayBuffer = /* @__PURE__ */ bufferType(require_type_constants.ELYSIA_TYPES.ArrayBuffer, () => require_type_typebox_type.Refine(require_type_typebox_type.Unsafe({ "~kind": "ArrayBuffer" }), (value) => value instanceof ArrayBuffer, () => "must be ArrayBuffer"));
 function ArrayBufferType(property) {
-	BaseArrayBuffer ??= (0, typebox_type.Refine)((0, typebox_type.Unsafe)({ "~kind": "ArrayBuffer" }), (value) => value instanceof ArrayBuffer, () => "must be ArrayBuffer");
-	if (!property || require_utils.isEmpty(property)) return emptyArrayBuffer ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ArrayBuffer, BaseArrayBuffer));
-	const refines = [[(value) => value instanceof ArrayBuffer, "must be ArrayBuffer"]];
-	if (property.minByteLength !== void 0) refines.push([(value) => value.byteLength >= property.minByteLength, `Expect byte to be more than ${property.minByteLength}`]);
-	if (property.maxByteLength !== void 0) refines.push([(value) => value.byteLength <= property.maxByteLength, `Expect byte to be less than ${property.maxByteLength}`]);
-	let schema = require_type_elysia_utils.Refines(BaseArrayBuffer, refines);
-	const [, meta] = require_type_elysia_utils.getMeta(property);
-	if (meta) {
-		schema = require_type_elysia_utils.cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ArrayBuffer, schema);
+	return arrayBuffer(property);
 }
 
 //#endregion
-exports.ArrayBufferType = ArrayBufferType;
+exports.ArrayBufferType = ArrayBufferType;
+exports.bufferType = bufferType;

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

@@ -1,25 +1,25 @@
 import { isEmpty } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
-import { Refines, cloneSchema, elyType, getMeta } from "./utils.mjs";
-import { Refine, Unsafe } from "typebox/type";
+import { Refine, Unsafe } from "../typebox-type.mjs";
+import { Refines, elyType, withMeta } from "./utils.mjs";
 
 //#region src/type/elysia/array-buffer.ts
-let BaseArrayBuffer;
-let emptyArrayBuffer;
+function bufferType(tag, base) {
+	let Base;
+	let empty;
+	return (property) => {
+		Base ??= base();
+		if (!property || isEmpty(property)) return empty ??= Object.freeze(elyType(tag, Base));
+		const refines = [];
+		if (property.minByteLength !== void 0) refines.push([(value) => value.byteLength >= property.minByteLength, `Expect byte to be more than ${property.minByteLength}`]);
+		if (property.maxByteLength !== void 0) refines.push([(value) => value.byteLength <= property.maxByteLength, `Expect byte to be less than ${property.maxByteLength}`]);
+		return elyType(tag, withMeta(Refines(Base, refines), property));
+	};
+}
+const arrayBuffer = /* @__PURE__ */ bufferType(ELYSIA_TYPES.ArrayBuffer, () => Refine(Unsafe({ "~kind": "ArrayBuffer" }), (value) => value instanceof ArrayBuffer, () => "must be ArrayBuffer"));
 function ArrayBufferType(property) {
-	BaseArrayBuffer ??= Refine(Unsafe({ "~kind": "ArrayBuffer" }), (value) => value instanceof ArrayBuffer, () => "must be ArrayBuffer");
-	if (!property || isEmpty(property)) return emptyArrayBuffer ??= Object.freeze(elyType(ELYSIA_TYPES.ArrayBuffer, BaseArrayBuffer));
-	const refines = [[(value) => value instanceof ArrayBuffer, "must be ArrayBuffer"]];
-	if (property.minByteLength !== void 0) refines.push([(value) => value.byteLength >= property.minByteLength, `Expect byte to be more than ${property.minByteLength}`]);
-	if (property.maxByteLength !== void 0) refines.push([(value) => value.byteLength <= property.maxByteLength, `Expect byte to be less than ${property.maxByteLength}`]);
-	let schema = Refines(BaseArrayBuffer, refines);
-	const [, meta] = getMeta(property);
-	if (meta) {
-		schema = cloneSchema(schema);
-		Object.assign(schema, meta);
-	}
-	return elyType(ELYSIA_TYPES.ArrayBuffer, schema);
+	return arrayBuffer(property);
 }
 
 //#endregion
-export { ArrayBufferType };
+export { ArrayBufferType, bufferType };

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

@@ -1,54 +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_bridge = require('../bridge.js');
 const require_type_constants = require('../constants.js');
 const require_type_elysia_array = require('./array.js');
-const require_type_elysia_string = require('./string.js');
+const require_type_elysia_json_string = require('./json-string.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/array-string.ts
-const MEMO_LIMIT = 8192;
 function ArrayString(property, _options) {
 	const [constraints, meta] = require_type_elysia_utils.getMeta(_options ?? require_utils.nullObject());
 	const array = require_type_elysia_array.ArrayType(property, constraints);
-	let check;
-	const checkInner = (value) => {
-		if (!check) try {
-			const compiled = require_type_bridge.Compile(array);
-			if (compiled.evaluateResult) compiled.evaluateResult.code = void 0;
-			if (compiled.buildResult) compiled.buildResult.functions = void 0;
-			check = (v) => compiled.Check(v);
-		} catch {
-			check = (v) => require_type_bridge.Check(array, v);
-		}
-		return check(value);
-	};
-	let raw;
-	let parsed;
-	const arrayString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.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 (value.length <= MEMO_LIMIT) {
-				raw = value;
-				parsed = next;
-			}
-			return true;
-		} catch {
-			return false;
-		}
-	}, () => "must be an array"), (value) => {
-		const decoded = value === raw ? parsed : JSON.parse(value);
-		raw = void 0;
-		parsed = void 0;
-		return require_type_bridge.Decode(array, decoded);
-	});
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ArrayString, require_type_elysia_union.Union([array, arrayString], meta));
+	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ArrayString, require_type_elysia_union.Union([array, require_type_elysia_json_string.jsonString(array, 91, "must be an array")], meta));
 }
 
 //#endregion

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

@@ -1,52 +1,15 @@
 import { nullObject } from "../../utils.mjs";
-import { Check, Compile, Decode as Decode$1 } from "../bridge.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { ArrayType } from "./array.mjs";
-import { StringType } from "./string.mjs";
+import { jsonString } from "./json-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;
 function ArrayString(property, _options) {
 	const [constraints, meta] = getMeta(_options ?? nullObject());
 	const array = ArrayType(property, constraints);
-	let check;
-	const checkInner = (value) => {
-		if (!check) try {
-			const compiled = Compile(array);
-			if (compiled.evaluateResult) compiled.evaluateResult.code = void 0;
-			if (compiled.buildResult) compiled.buildResult.functions = void 0;
-			check = (v) => compiled.Check(v);
-		} catch {
-			check = (v) => Check(array, v);
-		}
-		return check(value);
-	};
-	let raw;
-	let parsed;
-	const arrayString = Decode(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 (value.length <= MEMO_LIMIT) {
-				raw = value;
-				parsed = next;
-			}
-			return true;
-		} catch {
-			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 elyType(ELYSIA_TYPES.ArrayString, Union([array, arrayString], meta));
+	return elyType(ELYSIA_TYPES.ArrayString, Union([array, jsonString(array, 91, "must be an array")], meta));
 }
 
 //#endregion

package/dist/type/elysia/array.js

@@ -2,23 +2,19 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_utils = require('../../utils.js');
 
 //#region src/type/elysia/array.ts
-let arrayKind;
+const arrayKind = {
+	value: "Array",
+	enumerable: false
+};
 let arrayProto;
 function ArrayType(items, options) {
 	if (!options || require_utils.isEmpty(options)) {
-		arrayProto ??= Object.defineProperty({}, "~kind", {
-			value: "Array",
-			enumerable: false
-		});
+		arrayProto ??= Object.defineProperty({}, "~kind", arrayKind);
 		const schema = Object.create(arrayProto);
 		schema.type = "array";
 		schema.items = items;
 		return schema;
 	}
-	arrayKind ??= {
-		value: "Array",
-		enumerable: false
-	};
 	const schema = {
 		...options,
 		type: "array",

package/dist/type/elysia/array.mjs

@@ -1,23 +1,19 @@
 import { isEmpty } from "../../utils.mjs";
 
 //#region src/type/elysia/array.ts
-let arrayKind;
+const arrayKind = {
+	value: "Array",
+	enumerable: false
+};
 let arrayProto;
 function ArrayType(items, options) {
 	if (!options || isEmpty(options)) {
-		arrayProto ??= Object.defineProperty({}, "~kind", {
-			value: "Array",
-			enumerable: false
-		});
+		arrayProto ??= Object.defineProperty({}, "~kind", arrayKind);
 		const schema = Object.create(arrayProto);
 		schema.type = "array";
 		schema.items = items;
 		return schema;
 	}
-	arrayKind ??= {
-		value: "Array",
-		enumerable: false
-	};
 	const schema = {
 		...options,
 		type: "array",

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

package/dist/type/elysia/boolean.mjs

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

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

@@ -2,14 +2,13 @@ import { CookieValidatorOptions } from "../types.js";
 import { TObject, TProperties, TSchema } from "typebox";
 
 //#region src/type/elysia/cookie.d.ts
-interface CookieSchemaConfig extends CookieValidatorOptions {}
 interface TCookieObject<T extends TProperties> extends TObject<T> {
-  config?: CookieSchemaConfig;
+  config?: CookieValidatorOptions;
 }
 interface TCookieField {
-  config?: CookieSchemaConfig;
+  config?: CookieValidatorOptions;
 }
 declare function Cookie<T extends TProperties>(properties: T, options?: CookieValidatorOptions): TCookieObject<T>;
 declare function Cookie<T extends TSchema>(schema: T, options?: CookieValidatorOptions): T & TCookieField;
 //#endregion
-export { Cookie, CookieSchemaConfig, type CookieValidatorOptions, TCookieField, TCookieObject };
+export { Cookie, TCookieField, TCookieObject };

package/dist/type/elysia/cookie.js

@@ -13,29 +13,19 @@ const COOKIE_OPTION_KEYS = [
 	"secure",
 	"partitioned",
 	"secrets",
-	"sign"
+	"sign",
+	"legacySignature"
 ];
-function extractConfig(options) {
-	if (!options) return {
-		config: void 0,
-		rest: void 0
-	};
+const isSchema = (value) => !!value && typeof value === "object" && "~kind" in value;
+function Cookie(first, options) {
 	let config;
 	let rest;
-	for (const key in options) {
+	if (options) for (const key in options) {
 		const value = options[key];
 		if (value === void 0) continue;
 		if (COOKIE_OPTION_KEYS.includes(key)) (config ??= {})[key] = value;
 		else (rest ??= {})[key] = value;
 	}
-	return {
-		config,
-		rest
-	};
-}
-const isSchema = (value) => !!value && typeof value === "object" && "~kind" in value;
-function Cookie(first, options) {
-	const { config, rest } = extractConfig(options);
 	if (isSchema(first)) {
 		if (!config) return first;
 		const target = Object.create(Object.getPrototypeOf(first), Object.getOwnPropertyDescriptors(first));

package/dist/type/elysia/cookie.mjs

@@ -12,29 +12,19 @@ const COOKIE_OPTION_KEYS = [
 	"secure",
 	"partitioned",
 	"secrets",
-	"sign"
+	"sign",
+	"legacySignature"
 ];
-function extractConfig(options) {
-	if (!options) return {
-		config: void 0,
-		rest: void 0
-	};
+const isSchema = (value) => !!value && typeof value === "object" && "~kind" in value;
+function Cookie(first, options) {
 	let config;
 	let rest;
-	for (const key in options) {
+	if (options) for (const key in options) {
 		const value = options[key];
 		if (value === void 0) continue;
 		if (COOKIE_OPTION_KEYS.includes(key)) (config ??= {})[key] = value;
 		else (rest ??= {})[key] = value;
 	}
-	return {
-		config,
-		rest
-	};
-}
-const isSchema = (value) => !!value && typeof value === "object" && "~kind" in value;
-function Cookie(first, options) {
-	const { config, rest } = extractConfig(options);
 	if (isSchema(first)) {
 		if (!config) return first;
 		const target = Object.create(Object.getPrototypeOf(first), Object.getOwnPropertyDescriptors(first));

package/dist/type/elysia/date.js

@@ -1,37 +1,30 @@
 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$/;
 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 ??= (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) => {
-			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)()
+	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) => !isNaN(toDate(value).getTime()), () => "must be Date"),
+		require_type_elysia_number.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) => {
@@ -56,8 +49,8 @@ function DateWithProperty(options) {
 	let schema = StringifiedDate;
 	if (minMessage || maxMessage || xMinMessage || xMaxMessage || stepMessage) {
 		let failed = "must be Date";
-		schema = (0, typebox_type.Refine)(schema, (value) => {
-			const t = toTimestamp(value);
+		schema = require_type_typebox_type.Refine(schema, (value) => {
+			const t = value instanceof Date ? value.getTime() : toDate(value).getTime();
 			if (minMessage && t < min) {
 				failed = minMessage;
 				return false;