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

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

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_type_bridge = require('../bridge.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');
+
+//#region src/type/elysia/json-string.ts
+const MEMO_LIMIT = 8192;
+function jsonString(inner, open, message) {
+	let check;
+	let raw;
+	let parsed;
+	return require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), (value) => {
+		if (value.charCodeAt(0) !== open) return false;
+		if (value === raw) return true;
+		try {
+			const next = JSON.parse(value);
+			if (!check) try {
+				const compiled = require_type_bridge.Compile(inner);
+				require_type_shared.dropCompiledSource(compiled);
+				check = (v) => compiled.Check(v);
+			} catch {
+				check = (v) => require_type_bridge.Check(inner, v);
+			}
+			if (!check(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;
+		}
+	}, () => message), (value) => {
+		const decoded = value === raw ? parsed : JSON.parse(value);
+		raw = void 0;
+		parsed = void 0;
+		return require_type_bridge.Decode(inner, decoded);
+	});
+}
+
+//#endregion
+exports.jsonString = jsonString;

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

@@ -0,0 +1,46 @@
+import { Check, Compile, Decode } from "../bridge.mjs";
+import { dropCompiledSource } from "../shared.mjs";
+import { Decode as Decode$1, Refine } from "../typebox-type.mjs";
+import { StringType } from "./string.mjs";
+
+//#region src/type/elysia/json-string.ts
+const MEMO_LIMIT = 8192;
+function jsonString(inner, open, message) {
+	let check;
+	let raw;
+	let parsed;
+	return Decode$1(Refine(StringType(), (value) => {
+		if (value.charCodeAt(0) !== open) return false;
+		if (value === raw) return true;
+		try {
+			const next = JSON.parse(value);
+			if (!check) try {
+				const compiled = Compile(inner);
+				dropCompiledSource(compiled);
+				check = (v) => compiled.Check(v);
+			} catch {
+				check = (v) => Check(inner, v);
+			}
+			if (!check(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;
+		}
+	}, () => message), (value) => {
+		const decoded = value === raw ? parsed : JSON.parse(value);
+		raw = void 0;
+		parsed = void 0;
+		return Decode(inner, decoded);
+	});
+}
+
+//#endregion
+export { jsonString };

package/dist/type/elysia/keep-config.d.ts

@@ -0,0 +1,14 @@
+import { Composite, Evaluate, Interface, Mapped, Omit, Partial, Pick, ReadonlyObject, Required } from "../typebox-type.js";
+
+//#region src/type/elysia/keep-config.d.ts
+declare const CompositeType: typeof Composite;
+declare const EvaluateType: typeof Evaluate;
+declare const InterfaceType: typeof Interface;
+declare const MappedType: typeof Mapped;
+declare const OmitType: typeof Omit;
+declare const PartialType: typeof Partial;
+declare const PickType: typeof Pick;
+declare const ReadonlyObjectType: typeof ReadonlyObject;
+declare const RequiredType: typeof Required;
+//#endregion
+export { CompositeType, EvaluateType, InterfaceType, MappedType, OmitType, PartialType, PickType, ReadonlyObjectType, RequiredType };

package/dist/type/elysia/keep-config.js

@@ -0,0 +1,62 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils = require('../../utils.js');
+const require_type_typebox_type = require('../typebox-type.js');
+
+//#region src/type/elysia/keep-config.ts
+const carries = (schema, field = false, seen = /* @__PURE__ */ new Set()) => {
+	if (!schema || typeof schema !== "object" || seen.has(schema)) return false;
+	seen.add(schema);
+	if (schema.config !== void 0 || schema.$ref !== void 0 || schema["~kind"] === "Deferred" || require_utils.compositionKeys.some((key) => Array.isArray(schema[key]) && schema[key].some((member) => carries(member, field, seen)))) return true;
+	if (!field) {
+		for (const name in schema.properties) if (carries(schema.properties[name], true)) return true;
+	}
+	return false;
+};
+const from = (schema, sources) => Object.defineProperty(Object.create(Object.getPrototypeOf(schema), Object.getOwnPropertyDescriptors(schema)), "~cookieFrom", {
+	value: sources,
+	writable: true,
+	configurable: true
+});
+const keep = (build, sourcesOf) => ((...args) => {
+	const sources = sourcesOf(...args);
+	const result = build(...args);
+	if (!sources.some((source) => carries(source))) return result;
+	const built = from(result, sources);
+	const ref = built.$ref;
+	const replaced = sources[0]?.$defs?.[ref];
+	if (replaced && built.$defs?.[ref] && built.$defs[ref] !== replaced) built.$defs = {
+		...built.$defs,
+		[ref]: from(built.$defs[ref], [replaced])
+	};
+	return built;
+});
+const operand = (type, options) => [type, options];
+const indexed = (type, _, options) => [type, options];
+const CompositeType = /* @__PURE__ */ keep(require_type_typebox_type.Composite, (left, right) => [left, right]);
+const EvaluateType = /* @__PURE__ */ keep(require_type_typebox_type.Evaluate, operand);
+const InterfaceType = /* @__PURE__ */ keep(require_type_typebox_type.Interface, (heritage, properties, options) => [
+	...heritage,
+	{ properties },
+	options
+]);
+const MappedType = /* @__PURE__ */ keep(require_type_typebox_type.Mapped, (_, type, __, property, options) => [
+	type,
+	property,
+	options
+]);
+const OmitType = /* @__PURE__ */ keep(require_type_typebox_type.Omit, indexed);
+const PartialType = /* @__PURE__ */ keep(require_type_typebox_type.Partial, operand);
+const PickType = /* @__PURE__ */ keep(require_type_typebox_type.Pick, indexed);
+const ReadonlyObjectType = /* @__PURE__ */ keep(require_type_typebox_type.ReadonlyObject, operand);
+const RequiredType = /* @__PURE__ */ keep(require_type_typebox_type.Required, operand);
+
+//#endregion
+exports.CompositeType = CompositeType;
+exports.EvaluateType = EvaluateType;
+exports.InterfaceType = InterfaceType;
+exports.MappedType = MappedType;
+exports.OmitType = OmitType;
+exports.PartialType = PartialType;
+exports.PickType = PickType;
+exports.ReadonlyObjectType = ReadonlyObjectType;
+exports.RequiredType = RequiredType;

package/dist/type/elysia/keep-config.mjs

@@ -0,0 +1,53 @@
+import { compositionKeys } from "../../utils.mjs";
+import { Composite, Evaluate, Interface, Mapped, Omit, Partial, Pick, ReadonlyObject, Required } from "../typebox-type.mjs";
+
+//#region src/type/elysia/keep-config.ts
+const carries = (schema, field = false, seen = /* @__PURE__ */ new Set()) => {
+	if (!schema || typeof schema !== "object" || seen.has(schema)) return false;
+	seen.add(schema);
+	if (schema.config !== void 0 || schema.$ref !== void 0 || schema["~kind"] === "Deferred" || compositionKeys.some((key) => Array.isArray(schema[key]) && schema[key].some((member) => carries(member, field, seen)))) return true;
+	if (!field) {
+		for (const name in schema.properties) if (carries(schema.properties[name], true)) return true;
+	}
+	return false;
+};
+const from = (schema, sources) => Object.defineProperty(Object.create(Object.getPrototypeOf(schema), Object.getOwnPropertyDescriptors(schema)), "~cookieFrom", {
+	value: sources,
+	writable: true,
+	configurable: true
+});
+const keep = (build, sourcesOf) => ((...args) => {
+	const sources = sourcesOf(...args);
+	const result = build(...args);
+	if (!sources.some((source) => carries(source))) return result;
+	const built = from(result, sources);
+	const ref = built.$ref;
+	const replaced = sources[0]?.$defs?.[ref];
+	if (replaced && built.$defs?.[ref] && built.$defs[ref] !== replaced) built.$defs = {
+		...built.$defs,
+		[ref]: from(built.$defs[ref], [replaced])
+	};
+	return built;
+});
+const operand = (type, options) => [type, options];
+const indexed = (type, _, options) => [type, options];
+const CompositeType = /* @__PURE__ */ keep(Composite, (left, right) => [left, right]);
+const EvaluateType = /* @__PURE__ */ keep(Evaluate, operand);
+const InterfaceType = /* @__PURE__ */ keep(Interface, (heritage, properties, options) => [
+	...heritage,
+	{ properties },
+	options
+]);
+const MappedType = /* @__PURE__ */ keep(Mapped, (_, type, __, property, options) => [
+	type,
+	property,
+	options
+]);
+const OmitType = /* @__PURE__ */ keep(Omit, indexed);
+const PartialType = /* @__PURE__ */ keep(Partial, operand);
+const PickType = /* @__PURE__ */ keep(Pick, indexed);
+const ReadonlyObjectType = /* @__PURE__ */ keep(ReadonlyObject, operand);
+const RequiredType = /* @__PURE__ */ keep(Required, operand);
+
+//#endregion
+export { CompositeType, EvaluateType, InterfaceType, MappedType, OmitType, PartialType, PickType, ReadonlyObjectType, RequiredType };

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.d.ts

@@ -1,6 +1,7 @@
 import { TNumber, TNumberOptions } from "typebox";
 
 //#region src/type/elysia/number.d.ts
+declare function primitive(type: string, kind: string): (options?: object) => any;
 declare function NumberType(options?: TNumberOptions): TNumber;
 //#endregion
-export { NumberType };
+export { NumberType, primitive };

package/dist/type/elysia/number.js

@@ -1,20 +1,28 @@
 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)());
-function NumberType(options) {
-	if (!options || require_utils.isEmpty(options)) return emptyNumber;
-	const schema = {
-		...options,
-		type: "number",
-		"~kind": "Number"
+function primitive(type, kind) {
+	const empty = Object.freeze(Object.defineProperty({
+		type,
+		"~kind": kind
+	}, "~kind", require_type_constants.noEnumerable));
+	return (options) => {
+		if (!options || require_utils.isEmpty(options)) return empty;
+		const schema = {
+			...options,
+			type,
+			"~kind": kind
+		};
+		return Object.defineProperty(schema, "~kind", require_type_constants.noEnumerable);
 	};
-	return Object.defineProperty(schema, "~kind", require_type_constants.noEnumerable);
+}
+const number = /* @__PURE__ */ primitive("number", "Number");
+function NumberType(options) {
+	return number(options);
 }
 
 //#endregion
-exports.NumberType = NumberType;
+exports.NumberType = NumberType;
+exports.primitive = primitive;

package/dist/type/elysia/number.mjs

@@ -1,18 +1,26 @@
 import { isEmpty } from "../../utils.mjs";
 import { noEnumerable } from "../constants.mjs";
-import { Number } from "typebox/type";
 
 //#region src/type/elysia/number.ts
-const emptyNumber = Object.freeze(Number());
-function NumberType(options) {
-	if (!options || isEmpty(options)) return emptyNumber;
-	const schema = {
-		...options,
-		type: "number",
-		"~kind": "Number"
+function primitive(type, kind) {
+	const empty = Object.freeze(Object.defineProperty({
+		type,
+		"~kind": kind
+	}, "~kind", noEnumerable));
+	return (options) => {
+		if (!options || isEmpty(options)) return empty;
+		const schema = {
+			...options,
+			type,
+			"~kind": kind
+		};
+		return Object.defineProperty(schema, "~kind", noEnumerable);
 	};
-	return Object.defineProperty(schema, "~kind", noEnumerable);
+}
+const number = /* @__PURE__ */ primitive("number", "Number");
+function NumberType(options) {
+	return number(options);
 }
 
 //#endregion
-export { NumberType };
+export { NumberType, primitive };

package/dist/type/elysia/numeric-enum.d.ts

@@ -4,7 +4,7 @@ import { TSchemaOptions } from "typebox";
 type AssertNumericEnum<T extends Record<string, string | number>> = { [K in keyof T]: K extends number ? string : K extends `${number}` ? string : K extends string ? number : never };
 /**
  * Numeric enum: accepts a numeric string or a number, decodes to the
- * matching enum value. Mirrors src-old `t.NumericEnum`.
+ * matching enum value.
  */
 declare function NumericEnum<T extends AssertNumericEnum<T>>(item: T, property?: TSchemaOptions): any;
 //#endregion

package/dist/type/elysia/numeric-enum.js

@@ -1,20 +1,19 @@
 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_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');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/numeric-enum.ts
 /**
 * Numeric enum: accepts a numeric string or a number, decodes to the
-* matching enum value. Mirrors src-old `t.NumericEnum`.
+* matching enum value.
 */
 function NumericEnum(item, property) {
-	const allowed = new Set(Object.values(item).filter((v) => typeof v === "number").map((v) => v));
-	const decoder = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_union.Union([require_type_elysia_string.StringType({ format: "numeric" }), require_type_elysia_number.NumberType()], property), (value) => {
+	const allowed = new Set(Object.values(item).filter((v) => typeof v === "number"));
+	const decoder = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_union.Union([require_type_elysia_string.StringType({ format: "numeric" }), require_type_elysia_number.NumberType()], property), (value) => {
 		if (typeof value === "string" && value.trim() === "") return false;
 		const n = +value;
 		return !isNaN(n) && allowed.has(n);

package/dist/type/elysia/numeric-enum.mjs

@@ -1,17 +1,17 @@
 import { ELYSIA_TYPES } from "../constants.mjs";
+import { Decode, Refine } from "../typebox-type.mjs";
 import { StringType } from "./string.mjs";
 import { Union } from "./union.mjs";
 import { elyType } from "./utils.mjs";
 import { NumberType } from "./number.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/numeric-enum.ts
 /**
 * Numeric enum: accepts a numeric string or a number, decodes to the
-* matching enum value. Mirrors src-old `t.NumericEnum`.
+* matching enum value.
 */
 function NumericEnum(item, property) {
-	const allowed = new Set(Object.values(item).filter((v) => typeof v === "number").map((v) => v));
+	const allowed = new Set(Object.values(item).filter((v) => typeof v === "number"));
 	const decoder = Decode(Refine(Union([StringType({ format: "numeric" }), NumberType()], property), (value) => {
 		if (typeof value === "string" && value.trim() === "") return false;
 		const n = +value;

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

@@ -1,7 +1,9 @@
-import { TNumberOptions, Type } from "typebox";
+import { ELYSIA_TYPES } from "../constants.js";
+import { TNumberOptions, TSchema, Type } from "typebox";
 
 //#region src/type/elysia/numeric.d.ts
+declare function numericString(tag: ELYSIA_TYPES[keyof ELYSIA_TYPES], message: string, grammar: (value: string) => boolean, base: (constraints: TNumberOptions) => TSchema, emptyBase: () => TSchema): (property?: TNumberOptions) => Type.TSchema;
 type NumericSchema = Type.TUnion<[Type.TNumber, Type.TCodec<Type.TRefine<Type.TString>, number>]>;
 declare function Numeric(property?: TNumberOptions): Readonly<NumericSchema>;
 //#endregion
-export { Numeric };
+export { Numeric, numericString };

package/dist/type/elysia/numeric.js

@@ -1,13 +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');
 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');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/numeric.ts
 function isDecimalString(value) {
@@ -33,11 +32,10 @@ function isDecimalString(value) {
 		}
 		if (!digits && !fractions) return false;
 	} else if (!digits) return false;
-	return index === length;
+	if (index !== length) return false;
+	return digits < 309 || Number.isFinite(+value);
 }
-let StringifiedNumber;
-let emptyNumeric;
-function passesConstraints(n, c) {
+function inRange(n, c) {
 	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;
@@ -45,18 +43,23 @@ function passesConstraints(n, c) {
 	if (typeof c.multipleOf === "number" && n % c.multipleOf !== 0) return false;
 	return true;
 }
+function numericString(tag, message, grammar, base, emptyBase) {
+	let empty;
+	return (property) => {
+		if (!property || require_utils.isEmpty(property)) return empty ??= Object.freeze(require_type_elysia_utils.elyType(tag, require_type_elysia_union.Union([emptyBase(), require_type_shared.pureRefine(require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), grammar, () => message), (value) => +value))])));
+		const [constraints, meta] = require_type_elysia_utils.getMeta(property);
+		const c = constraints;
+		const number = base(constraints);
+		const stringified = require_type_typebox_type.Decode(require_type_typebox_type.Refine(require_type_elysia_string.StringType(), (value) => grammar(value) && inRange(+value, c), () => message), (value) => +value);
+		require_type_shared.pureRefine(stringified);
+		return require_type_elysia_utils.elyType(tag, require_type_elysia_union.Union([number, stringified], meta));
+	};
+}
+const numeric = /* @__PURE__ */ numericString(require_type_constants.ELYSIA_TYPES.Numeric, "must be number", isDecimalString, require_type_elysia_number.NumberType, require_type_elysia_number.NumberType);
 function Numeric(property) {
-	StringifiedNumber ??= require_type_shared.pureRefine((0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), isDecimalString, () => "must be number"), (value) => +value));
-	if (!property || require_utils.isEmpty(property)) return emptyNumeric ??= Object.freeze(require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Numeric, require_type_elysia_union.Union([require_type_elysia_number.NumberType(), StringifiedNumber])));
-	const [constraints, meta] = require_type_elysia_utils.getMeta(property);
-	const number = require_type_elysia_number.NumberType(constraints);
-	const stringified = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
-		if (!isDecimalString(value)) return false;
-		return passesConstraints(+value, constraints);
-	}, () => "must be number"), (value) => +value);
-	require_type_shared.pureRefine(stringified);
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.Numeric, require_type_elysia_union.Union([number, stringified], meta));
+	return numeric(property);
 }
 
 //#endregion
-exports.Numeric = Numeric;
+exports.Numeric = Numeric;
+exports.numericString = numericString;

package/dist/type/elysia/numeric.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 { NumberType } from "./number.mjs";
-import { Decode, Refine } from "typebox/type";
 
 //#region src/type/elysia/numeric.ts
 function isDecimalString(value) {
@@ -31,11 +31,10 @@ function isDecimalString(value) {
 		}
 		if (!digits && !fractions) return false;
 	} else if (!digits) return false;
-	return index === length;
+	if (index !== length) return false;
+	return digits < 309 || Number.isFinite(+value);
 }
-let StringifiedNumber;
-let emptyNumeric;
-function passesConstraints(n, c) {
+function inRange(n, c) {
 	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;
@@ -43,18 +42,22 @@ function passesConstraints(n, c) {
 	if (typeof c.multipleOf === "number" && n % c.multipleOf !== 0) return false;
 	return true;
 }
+function numericString(tag, message, grammar, base, emptyBase) {
+	let empty;
+	return (property) => {
+		if (!property || isEmpty(property)) return empty ??= Object.freeze(elyType(tag, Union([emptyBase(), pureRefine(Decode(Refine(StringType(), grammar, () => message), (value) => +value))])));
+		const [constraints, meta] = getMeta(property);
+		const c = constraints;
+		const number = base(constraints);
+		const stringified = Decode(Refine(StringType(), (value) => grammar(value) && inRange(+value, c), () => message), (value) => +value);
+		pureRefine(stringified);
+		return elyType(tag, Union([number, stringified], meta));
+	};
+}
+const numeric = /* @__PURE__ */ numericString(ELYSIA_TYPES.Numeric, "must be number", isDecimalString, NumberType, NumberType);
 function Numeric(property) {
-	StringifiedNumber ??= pureRefine(Decode(Refine(StringType(), isDecimalString, () => "must be number"), (value) => +value));
-	if (!property || isEmpty(property)) return emptyNumeric ??= Object.freeze(elyType(ELYSIA_TYPES.Numeric, Union([NumberType(), StringifiedNumber])));
-	const [constraints, meta] = getMeta(property);
-	const number = NumberType(constraints);
-	const stringified = Decode(Refine(StringType(), (value) => {
-		if (!isDecimalString(value)) return false;
-		return passesConstraints(+value, constraints);
-	}, () => "must be number"), (value) => +value);
-	pureRefine(stringified);
-	return elyType(ELYSIA_TYPES.Numeric, Union([number, stringified], meta));
+	return numeric(property);
 }
 
 //#endregion
-export { Numeric };
+export { Numeric, numericString };

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

@@ -1,51 +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_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');
 const require_type_elysia_object = require('./object.js');
-let typebox_type = require("typebox/type");
 
 //#region src/type/elysia/object-string.ts
-const MEMO_LIMIT = 8192;
 function ObjectString(property, _options) {
 	const [{ properties, ...constraints }, meta] = require_type_elysia_utils.getMeta(_options ?? require_utils.nullObject());
 	const object = require_type_elysia_object.ObjectType(property, constraints);
-	let check;
-	let raw;
-	let parsed;
-	const objectString = (0, typebox_type.Decode)((0, typebox_type.Refine)(require_type_elysia_string.StringType(), (value) => {
-		if (value.charCodeAt(0) !== 123) return false;
-		if (value === raw) return true;
-		try {
-			const next = JSON.parse(value);
-			if (!check) try {
-				const compiled = require_type_bridge.Compile(object);
-				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(object, v);
-			}
-			if (!check(next)) return false;
-			if (value.length <= MEMO_LIMIT) {
-				raw = value;
-				parsed = next;
-			}
-			return true;
-		} catch {
-			return false;
-		}
-	}, () => "must be an object"), (value) => {
-		const decoded = value === raw ? parsed : JSON.parse(value);
-		raw = void 0;
-		parsed = void 0;
-		return require_type_bridge.Decode(object, decoded);
-	});
-	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ObjectString, require_type_elysia_union.Union([object, objectString], meta));
+	return require_type_elysia_utils.elyType(require_type_constants.ELYSIA_TYPES.ObjectString, require_type_elysia_union.Union([object, require_type_elysia_json_string.jsonString(object, 123, "must be an object")], meta));
 }
 
 //#endregion