elysia 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/sucrose.js

@@ -135,29 +135,31 @@ function removeColonAlias(parameter) {
 function retrieveRootparameters(parameter) {
 	let hasParenthesis = false;
 	if (parameter.charCodeAt(0) === 40) parameter = parameter.slice(1, -1);
+	parameter = parameter.trim();
+	if (parameter.indexOf("=") !== -1) parameter = removeDefaultParameter(parameter);
 	if (parameter.charCodeAt(0) === 123) {
 		hasParenthesis = true;
 		const [, end] = bracketPairRange(parameter);
 		parameter = parameter.slice(1, end - 1);
 	}
-	parameter = parameter.replace(/[ \t\n]/g, "");
-	let parameters = [];
+	parameter = parameter.replace(/\s+/g, "");
+	const parameters = [];
 	while (true) {
 		let [start, end] = bracketPairRange(parameter);
 		if (start === -1) break;
-		parameters.push(parameter.slice(0, start - 1));
+		parameters.push(removeColonAlias(parameter.slice(0, start - 1)));
 		if (parameter.charCodeAt(end) === 44) end++;
 		parameter = parameter.slice(end);
 	}
 	parameter = removeColonAlias(parameter);
-	if (parameter) parameters = parameters.concat(parameter.split(","));
+	if (parameter) parameters.push(parameter);
 	const parameterMap = Object.create(null);
 	for (const p of parameters) {
 		if (p.indexOf(",") === -1) {
-			parameterMap[removeDefaultParameter(p)] = true;
+			parameterMap[p] = true;
 			continue;
 		}
-		for (const q of p.split(",")) parameterMap[removeDefaultParameter(q.trim())] = true;
+		for (const q of p.split(",")) parameterMap[q] = true;
 	}
 	return {
 		hasParenthesis,
@@ -255,18 +257,118 @@ function findAlias(type, body, seen = /* @__PURE__ */ new Set()) {
 	}
 	return aliases;
 }
+/**
+* Whitespace as JavaScript defines it, which is what `\s` matches: everything
+* `String.prototype.trim` removes, not just the three characters that happen to
+* appear in LF-formatted source.
+*/
+const isWhitespace = (char) => char === 32 || char >= 9 && char <= 13 || char === 160 || char === 5760 || char >= 8192 && char <= 8202 || char === 8232 || char === 8233 || char === 8239 || char === 8287 || char === 12288 || char === 65279;
+/**
+* Words that lex as an identifier but are operators, so a `/` after one opens a
+* regex instead of dividing. Padded so a lookup cannot match a substring.
+*/
+const operatorKeyword = " typeof void delete in of instanceof new return case do else yield await throw ";
+/**
+* Skip a regular expression literal, so a `,`, `}` or quote inside it is not
+* mistaken for structure.
+*/
+function skipRegexLiteral(parameter, start, regexEnd) {
+	let previous = start - 1;
+	while (previous >= 0 && isWhitespace(parameter.charCodeAt(previous))) previous--;
+	if (previous >= 0) {
+		const char = parameter.charCodeAt(previous);
+		if (isIdentifierPart(char)) {
+			let identifier = previous;
+			while (identifier >= 0 && isIdentifierPart(parameter.charCodeAt(identifier))) identifier--;
+			if (parameter.charCodeAt(identifier) === 46 || !operatorKeyword.includes(" " + parameter.slice(identifier + 1, previous + 1) + " ")) return start;
+		} else if (char === 41 || char === 93 || char === 125 || char === 39 || char === 34 || char === 96 || char === 47 && previous === regexEnd) return start;
+	}
+	let inCharacterClass = false;
+	for (let index = start + 1; index < parameter.length; index++) {
+		const char = parameter.charCodeAt(index);
+		if (char === 92) index++;
+		else if (char === 91) inCharacterClass = true;
+		else if (char === 93) inCharacterClass = false;
+		else if (char === 47 && !inCharacterClass) return index;
+	}
+	return start;
+}
+/**
+* Find where a default parameter value ends: the first `,` or `}` that is
+* outside a string or regex literal and not nested inside `()`, `[]`, or `{}`
+*
+* Returns -1 when the value runs until the end of the string
+*/
+function findDefaultValueEnd(parameter, start) {
+	let deep = 0;
+	let quote = 0;
+	let regexEnd = -1;
+	let template;
+	for (let index = start; index < parameter.length; index++) {
+		const char = parameter.charCodeAt(index);
+		if (quote !== 0) {
+			if (char === 92) index++;
+			else if (char === quote) quote = 0;
+			else if (quote === 96 && char === 36 && parameter.charCodeAt(index + 1) === 123) {
+				(template ??= []).push(deep);
+				quote = 0;
+				deep++;
+				index++;
+			}
+			continue;
+		}
+		switch (char) {
+			case 39:
+			case 34:
+			case 96:
+				quote = char;
+				break;
+			case 47: {
+				const closing = skipRegexLiteral(parameter, index, regexEnd);
+				if (closing !== index) regexEnd = closing;
+				index = closing;
+				break;
+			}
+			case 40:
+			case 91:
+			case 123:
+				deep++;
+				break;
+			case 41:
+			case 93:
+				if (deep !== 0) deep--;
+				break;
+			case 125:
+				if (deep === 0) return index;
+				deep--;
+				if (template !== void 0 && template[template.length - 1] === deep) {
+					template.pop();
+					quote = 96;
+				}
+				break;
+			case 44:
+				if (deep === 0) return index;
+				break;
+		}
+	}
+	return -1;
+}
 function removeDefaultParameter(parameter) {
-	while (true) {
-		const index = parameter.indexOf("=");
-		if (index === -1) break;
-		const commaIndex = parameter.indexOf(",", index);
-		const bracketIndex = parameter.indexOf("}", index);
-		const end = commaIndex === -1 ? bracketIndex : bracketIndex === -1 ? commaIndex : Math.min(commaIndex, bracketIndex);
-		if (end === -1) {
-			parameter = parameter.slice(0, index);
-			break;
+	let index = parameter.indexOf("=");
+	if (index !== -1) {
+		let kept = "";
+		let copyFrom = 0;
+		for (; index < parameter.length; index++) {
+			if (parameter.charCodeAt(index) !== 61) continue;
+			kept += parameter.slice(copyFrom, index);
+			const end = findDefaultValueEnd(parameter, index + 1);
+			if (end === -1) {
+				copyFrom = parameter.length;
+				break;
+			}
+			copyFrom = index = end;
 		}
-		parameter = parameter.slice(0, index) + parameter.slice(end);
+		parameter = kept + parameter.slice(copyFrom);
 	}
 	return parameter.split(",").map((i) => i.trim()).join(", ");
 }

package/dist/sucrose.mjs

@@ -134,29 +134,31 @@ function removeColonAlias(parameter) {
 function retrieveRootparameters(parameter) {
 	let hasParenthesis = false;
 	if (parameter.charCodeAt(0) === 40) parameter = parameter.slice(1, -1);
+	parameter = parameter.trim();
+	if (parameter.indexOf("=") !== -1) parameter = removeDefaultParameter(parameter);
 	if (parameter.charCodeAt(0) === 123) {
 		hasParenthesis = true;
 		const [, end] = bracketPairRange(parameter);
 		parameter = parameter.slice(1, end - 1);
 	}
-	parameter = parameter.replace(/[ \t\n]/g, "");
-	let parameters = [];
+	parameter = parameter.replace(/\s+/g, "");
+	const parameters = [];
 	while (true) {
 		let [start, end] = bracketPairRange(parameter);
 		if (start === -1) break;
-		parameters.push(parameter.slice(0, start - 1));
+		parameters.push(removeColonAlias(parameter.slice(0, start - 1)));
 		if (parameter.charCodeAt(end) === 44) end++;
 		parameter = parameter.slice(end);
 	}
 	parameter = removeColonAlias(parameter);
-	if (parameter) parameters = parameters.concat(parameter.split(","));
+	if (parameter) parameters.push(parameter);
 	const parameterMap = Object.create(null);
 	for (const p of parameters) {
 		if (p.indexOf(",") === -1) {
-			parameterMap[removeDefaultParameter(p)] = true;
+			parameterMap[p] = true;
 			continue;
 		}
-		for (const q of p.split(",")) parameterMap[removeDefaultParameter(q.trim())] = true;
+		for (const q of p.split(",")) parameterMap[q] = true;
 	}
 	return {
 		hasParenthesis,
@@ -254,18 +256,118 @@ function findAlias(type, body, seen = /* @__PURE__ */ new Set()) {
 	}
 	return aliases;
 }
+/**
+* Whitespace as JavaScript defines it, which is what `\s` matches: everything
+* `String.prototype.trim` removes, not just the three characters that happen to
+* appear in LF-formatted source.
+*/
+const isWhitespace = (char) => char === 32 || char >= 9 && char <= 13 || char === 160 || char === 5760 || char >= 8192 && char <= 8202 || char === 8232 || char === 8233 || char === 8239 || char === 8287 || char === 12288 || char === 65279;
+/**
+* Words that lex as an identifier but are operators, so a `/` after one opens a
+* regex instead of dividing. Padded so a lookup cannot match a substring.
+*/
+const operatorKeyword = " typeof void delete in of instanceof new return case do else yield await throw ";
+/**
+* Skip a regular expression literal, so a `,`, `}` or quote inside it is not
+* mistaken for structure.
+*/
+function skipRegexLiteral(parameter, start, regexEnd) {
+	let previous = start - 1;
+	while (previous >= 0 && isWhitespace(parameter.charCodeAt(previous))) previous--;
+	if (previous >= 0) {
+		const char = parameter.charCodeAt(previous);
+		if (isIdentifierPart(char)) {
+			let identifier = previous;
+			while (identifier >= 0 && isIdentifierPart(parameter.charCodeAt(identifier))) identifier--;
+			if (parameter.charCodeAt(identifier) === 46 || !operatorKeyword.includes(" " + parameter.slice(identifier + 1, previous + 1) + " ")) return start;
+		} else if (char === 41 || char === 93 || char === 125 || char === 39 || char === 34 || char === 96 || char === 47 && previous === regexEnd) return start;
+	}
+	let inCharacterClass = false;
+	for (let index = start + 1; index < parameter.length; index++) {
+		const char = parameter.charCodeAt(index);
+		if (char === 92) index++;
+		else if (char === 91) inCharacterClass = true;
+		else if (char === 93) inCharacterClass = false;
+		else if (char === 47 && !inCharacterClass) return index;
+	}
+	return start;
+}
+/**
+* Find where a default parameter value ends: the first `,` or `}` that is
+* outside a string or regex literal and not nested inside `()`, `[]`, or `{}`
+*
+* Returns -1 when the value runs until the end of the string
+*/
+function findDefaultValueEnd(parameter, start) {
+	let deep = 0;
+	let quote = 0;
+	let regexEnd = -1;
+	let template;
+	for (let index = start; index < parameter.length; index++) {
+		const char = parameter.charCodeAt(index);
+		if (quote !== 0) {
+			if (char === 92) index++;
+			else if (char === quote) quote = 0;
+			else if (quote === 96 && char === 36 && parameter.charCodeAt(index + 1) === 123) {
+				(template ??= []).push(deep);
+				quote = 0;
+				deep++;
+				index++;
+			}
+			continue;
+		}
+		switch (char) {
+			case 39:
+			case 34:
+			case 96:
+				quote = char;
+				break;
+			case 47: {
+				const closing = skipRegexLiteral(parameter, index, regexEnd);
+				if (closing !== index) regexEnd = closing;
+				index = closing;
+				break;
+			}
+			case 40:
+			case 91:
+			case 123:
+				deep++;
+				break;
+			case 41:
+			case 93:
+				if (deep !== 0) deep--;
+				break;
+			case 125:
+				if (deep === 0) return index;
+				deep--;
+				if (template !== void 0 && template[template.length - 1] === deep) {
+					template.pop();
+					quote = 96;
+				}
+				break;
+			case 44:
+				if (deep === 0) return index;
+				break;
+		}
+	}
+	return -1;
+}
 function removeDefaultParameter(parameter) {
-	while (true) {
-		const index = parameter.indexOf("=");
-		if (index === -1) break;
-		const commaIndex = parameter.indexOf(",", index);
-		const bracketIndex = parameter.indexOf("}", index);
-		const end = commaIndex === -1 ? bracketIndex : bracketIndex === -1 ? commaIndex : Math.min(commaIndex, bracketIndex);
-		if (end === -1) {
-			parameter = parameter.slice(0, index);
-			break;
+	let index = parameter.indexOf("=");
+	if (index !== -1) {
+		let kept = "";
+		let copyFrom = 0;
+		for (; index < parameter.length; index++) {
+			if (parameter.charCodeAt(index) !== 61) continue;
+			kept += parameter.slice(copyFrom, index);
+			const end = findDefaultValueEnd(parameter, index + 1);
+			if (end === -1) {
+				copyFrom = parameter.length;
+				break;
+			}
+			copyFrom = index = end;
 		}
-		parameter = parameter.slice(0, index) + parameter.slice(end);
+		parameter = kept + parameter.slice(copyFrom);
 	}
 	return parameter.split(",").map((i) => i.trim()).join(", ");
 }

package/dist/type/bridge.d.ts

@@ -1,17 +1,17 @@
-import { Intersect as Intersect$1 } from "./elysia/intersect.js";
+import { Intersect as Intersect$2 } from "./elysia/intersect.js";
 import { hasTypes as hasTypes$1 } from "./utils.js";
 import { TypeBoxValidatorCache as TypeBoxValidatorCache$1, mayHaveFileType as mayHaveFileType$1 } from "./validator/validator-cache.js";
 import { TypeBoxValidator as TypeBoxValidator$1 } from "./validator/index.js";
 import { applyCoercions as applyCoercions$1, coerceBody as coerceBody$1, coerceFormData as coerceFormData$1, coerceQuery as coerceQuery$1, coerceRoot as coerceRoot$1, coerceStringToStructure as coerceStringToStructure$1 } from "./coerce.js";
 import { Ref as Ref$1, TAny, TSchema } from "typebox/type";
 import { Compile as Compile$1 } from "typebox/compile";
-import { Check as Check$1, Clone as Clone$1, Create as Create$1, Decode as Decode$1, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
+import { Check as Check$1, Clone as Clone$1, Create as Create$1, Decode as Decode$2, Default as Default$1, HasCodec as HasCodec$1 } from "typebox/value";
 
 //#region src/type/bridge.d.ts
 interface TypeboxModule {
   Compile: typeof Compile$1;
   Create: typeof Create$1;
-  Decode: typeof Decode$1;
+  Decode: typeof Decode$2;
   applyCoercions: typeof applyCoercions$1;
   TypeBoxValidator: TypeBoxValidator$1;
   TypeBoxValidatorCache: TypeBoxValidatorCache$1;
@@ -23,7 +23,7 @@ interface TypeboxModule {
   hasTypes: typeof hasTypes$1;
   mayHaveFileType: typeof mayHaveFileType$1;
   HasCodec: typeof HasCodec$1;
-  Intersect: typeof Intersect$1;
+  Intersect: typeof Intersect$2;
   Default: typeof Default$1;
   Ref: typeof Ref$1;
   Clone: typeof Clone$1;
@@ -31,7 +31,7 @@ interface TypeboxModule {
 }
 declare let Compile: typeof Compile$1;
 declare let Create: typeof Create$1;
-declare let Decode: typeof Decode$1;
+declare let Decode: typeof Decode$2;
 declare let applyCoercions: typeof applyCoercions$1;
 declare let TypeBoxValidator: TypeBoxValidator$1;
 type TypeBoxValidator<T extends TSchema = TAny> = TypeBoxValidator$1<T>;
@@ -45,7 +45,7 @@ declare let coerceBody: typeof coerceBody$1;
 declare let hasTypes: typeof hasTypes$1;
 declare let mayHaveFileType: typeof mayHaveFileType$1;
 declare let HasCodec: typeof HasCodec$1;
-declare let Intersect: typeof Intersect$1;
+declare let Intersect: typeof Intersect$2;
 declare let Default: typeof Default$1;
 declare let Ref: typeof Ref$1;
 declare let Clone: typeof Clone$1;

package/dist/type/coerce.js

@@ -227,10 +227,15 @@ const coerceQuery = () => _coerceQuery ??= [[[["Object", toObjectString], ["Arra
 let _coerceBody;
 const coerceBody = () => _coerceBody ??= [[[["Number", require_type_elysia_numeric.Numeric], ["Boolean", require_type_elysia_boolean_string.BooleanString]], { root: true }], [[["Integer", require_type_elysia_integer_string.IntegerString]]]];
 let _coerceFormData;
-const coerceFormData = () => _coerceFormData ??= [[[["Object", toObjectString]], { rootPropertiesOnly: true }], [[["Array", toArrayString]], {
-	root: false,
-	onlyFirst: "array"
-}]];
+const coerceFormData = () => _coerceFormData ??= [
+	[[["Integer", require_type_elysia_integer_string.IntegerString]]],
+	...coerceRoot(),
+	[[["Object", toObjectString]], { rootPropertiesOnly: true }],
+	[[["Array", toArrayString]], {
+		root: false,
+		onlyFirst: "array"
+	}]
+];
 let _coerceStringToStructure;
 const coerceStringToStructure = () => _coerceStringToStructure ??= [[[["Object", toObjectString], ["Array", toArrayString]], { rootPropertiesOnly: true }], ...coerceRoot()];
 function applyCoercions(schema, coerces) {

package/dist/type/coerce.mjs

@@ -226,10 +226,15 @@ const coerceQuery = () => _coerceQuery ??= [[[["Object", toObjectString], ["Arra
 let _coerceBody;
 const coerceBody = () => _coerceBody ??= [[[["Number", Numeric], ["Boolean", BooleanString]], { root: true }], [[["Integer", IntegerString]]]];
 let _coerceFormData;
-const coerceFormData = () => _coerceFormData ??= [[[["Object", toObjectString]], { rootPropertiesOnly: true }], [[["Array", toArrayString]], {
-	root: false,
-	onlyFirst: "array"
-}]];
+const coerceFormData = () => _coerceFormData ??= [
+	[[["Integer", IntegerString]]],
+	...coerceRoot(),
+	[[["Object", toObjectString]], { rootPropertiesOnly: true }],
+	[[["Array", toArrayString]], {
+		root: false,
+		onlyFirst: "array"
+	}]
+];
 let _coerceStringToStructure;
 const coerceStringToStructure = () => _coerceStringToStructure ??= [[[["Object", toObjectString], ["Array", toArrayString]], { rootPropertiesOnly: true }], ...coerceRoot()];
 function applyCoercions(schema, coerces) {

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

@@ -10,17 +10,44 @@ 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 {
-			return require_type_bridge.Check(array, JSON.parse(value));
+			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) => require_type_bridge.Decode(array, JSON.parse(value)));
+	}, () => "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));
 }
 

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

@@ -1,5 +1,5 @@
 import { nullObject } from "../../utils.mjs";
-import { Check, Decode as Decode$1 } from "../bridge.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";
@@ -8,17 +8,44 @@ 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 {
-			return Check(array, JSON.parse(value));
+			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) => Decode$1(array, JSON.parse(value)));
+	}, () => "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));
 }
 

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

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_universal_is_production = require('../../universal/is-production.js');
 const require_compile_utils = require('../../compile/utils.js');
 
 //#region src/type/elysia/file-type.ts
@@ -6,6 +7,11 @@ let fileTypeDetectors;
 function setFileTypeDetector(detector) {
 	fileTypeDetectors = Array.isArray(detector) ? detector : [detector];
 }
+let warnedMissingDetector = false;
+function warnMissingFileTypeDetector() {
+	warnedMissingDetector = true;
+	console.warn("[elysia] missing file type detector");
+}
 async function detectFileType(file) {
 	for (let i = 0; i < fileTypeDetectors.length; i++) {
 		const result = await fileTypeDetectors[i](file);
@@ -18,7 +24,10 @@ async function fileType(file, type) {
 	if (!file) return false;
 	const types = typeof type === "string" ? [type] : type;
 	if (!matchesAnyFileType(file.type, types)) return false;
-	if (!fileTypeDetectors) return false;
+	if (!fileTypeDetectors) {
+		if (!require_universal_is_production.isProduction() && !warnedMissingDetector) warnMissingFileTypeDetector();
+		return false;
+	}
 	const mime = await detectFileType(file);
 	if (mime && matchesAnyFileType(mime, types)) return true;
 	return false;
@@ -39,6 +48,7 @@ function takeFileTypeChecks() {
 function maybeQueueFileTypeCheck(value, types, message) {
 	if (!collecting) return;
 	if (!fileTypeDetectors) {
+		if (!require_universal_is_production.isProduction() && !warnedMissingDetector) warnMissingFileTypeDetector();
 		(pendingFileTypeChecks ??= []).push({
 			file: value,
 			check: Promise.resolve(message)

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

@@ -1,3 +1,4 @@
+import { isProduction } from "../../universal/is-production.mjs";
 import { isAsyncFunction } from "../../compile/utils.mjs";
 
 //#region src/type/elysia/file-type.ts
@@ -5,6 +6,11 @@ let fileTypeDetectors;
 function setFileTypeDetector(detector) {
 	fileTypeDetectors = Array.isArray(detector) ? detector : [detector];
 }
+let warnedMissingDetector = false;
+function warnMissingFileTypeDetector() {
+	warnedMissingDetector = true;
+	console.warn("[elysia] missing file type detector");
+}
 async function detectFileType(file) {
 	for (let i = 0; i < fileTypeDetectors.length; i++) {
 		const result = await fileTypeDetectors[i](file);
@@ -17,7 +23,10 @@ async function fileType(file, type) {
 	if (!file) return false;
 	const types = typeof type === "string" ? [type] : type;
 	if (!matchesAnyFileType(file.type, types)) return false;
-	if (!fileTypeDetectors) return false;
+	if (!fileTypeDetectors) {
+		if (!isProduction() && !warnedMissingDetector) warnMissingFileTypeDetector();
+		return false;
+	}
 	const mime = await detectFileType(file);
 	if (mime && matchesAnyFileType(mime, types)) return true;
 	return false;
@@ -38,6 +47,7 @@ function takeFileTypeChecks() {
 function maybeQueueFileTypeCheck(value, types, message) {
 	if (!collecting) return;
 	if (!fileTypeDetectors) {
+		if (!isProduction() && !warnedMissingDetector) warnMissingFileTypeDetector();
 		(pendingFileTypeChecks ??= []).push({
 			file: value,
 			check: Promise.resolve(message)

package/dist/type/elysia/form.js

@@ -1,5 +1,6 @@
 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_utils = require('./utils.js');
 const require_type_elysia_object = require('./object.js');
@@ -9,7 +10,7 @@ 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) => typeof value === "object" && value !== null && "~ely-form" in value, () => "must be instance of Elysia.form"), (value) => value));
+	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));
 	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,3 +1,4 @@
+import { isElysiaForm } from "../../utils.mjs";
 import { ELYSIA_TYPES } from "../constants.mjs";
 import { elyType } from "./utils.mjs";
 import { ObjectType } from "./object.mjs";
@@ -7,7 +8,7 @@ import { Decode, Refine, Unsafe } from "typebox/type";
 //#region src/type/elysia/form.ts
 let BaseForm;
 const Form = (property, options) => {
-	BaseForm ??= Object.freeze(Decode(Refine(Unsafe({ "~kind": "FormData" }), (value) => typeof value === "object" && value !== null && "~ely-form" in value, () => "must be instance of Elysia.form"), (value) => value));
+	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)]));
 };