elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/type/validator/string-codec-aot.mjs

@@ -0,0 +1,102 @@
+import { Capture, collectExternals, instantiateFrozenDecodeMirror } from "../../compile/aot.mjs";
+import { ELYSIA_TYPES } from "../constants.mjs";
+import { hasProperty } from "../utils.mjs";
+import { buildFrozenCheck } from "./frozen-check.mjs";
+import { Build, Compile } from "typebox/schema";
+import createMirror from "exact-mirror";
+
+//#region src/type/validator/string-codec-aot.ts
+function collectStringCodecNodes(schema, out = []) {
+	if (!schema || typeof schema !== "object") return out;
+	const ely = schema["~elyTyp"];
+	if (ely === ELYSIA_TYPES.ObjectString || ely === ELYSIA_TYPES.ArrayString) {
+		const inner = schema.anyOf?.[0];
+		const codec = schema.anyOf?.[1];
+		if (inner && codec?.["~codec"] && codec["~refine"]) out.push({
+			inner,
+			codec,
+			open: ely === ELYSIA_TYPES.ObjectString ? 123 : 91
+		});
+	}
+	if (schema.properties) for (const k in schema.properties) collectStringCodecNodes(schema.properties[k], out);
+	const items = schema.items;
+	if (Array.isArray(items)) for (const it of items) collectStringCodecNodes(it, out);
+	else if (items) collectStringCodecNodes(items, out);
+	if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectStringCodecNodes(b, out);
+	return out;
+}
+function reconstructInnerCodecs(ic, schema) {
+	const nodes = collectStringCodecNodes(schema);
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const entry = ic[i];
+		const node = nodes[i];
+		if (!entry || !node) continue;
+		const innerSchema = node.inner;
+		const innerCheck = entry.c(entry.e ? collectExternals(innerSchema) : []);
+		const innerMirror = entry.d.x ? instantiateFrozenDecodeMirror(entry.d, innerSchema) : entry.d.s;
+		const open = entry.o;
+		node.codec["~refine"][0].check = (v) => {
+			if (v.charCodeAt(0) !== open) return false;
+			try {
+				return innerCheck(JSON.parse(v));
+			} catch {
+				return false;
+			}
+		};
+		node.codec["~codec"].decode = (v) => innerMirror(JSON.parse(v));
+	}
+}
+function captureInnerCodec(inner, open, sanitize) {
+	let cf;
+	try {
+		cf = buildFrozenCheck(Build(inner), inner);
+		if (!cf) return;
+	} catch {
+		return;
+	}
+	let decode;
+	try {
+		const emitted = createMirror(inner, {
+			Compile,
+			sanitize,
+			decode: true,
+			emit: true
+		});
+		if (typeof emitted?.source !== "string") return;
+		const ext = emitted.externals;
+		if (ext?.hof) return;
+		if (ext?.codecs && !Capture.mirrorCodecs(inner, ext.codecs)) return;
+		let u;
+		if (ext?.unions && ext.unions.length) {
+			u = Capture.mirrorUnions(inner, ext.unions);
+			if (!u) return;
+		}
+		decode = {
+			source: emitted.source,
+			hasExternals: !!(ext?.codecs || u),
+			u
+		};
+	} catch {
+		return;
+	}
+	if (hasProperty("default", inner)) return;
+	return {
+		open,
+		...cf,
+		decode
+	};
+}
+function captureStringCodecEntries(schema, sanitize) {
+	const stringCodecs = collectStringCodecNodes(schema);
+	if (!stringCodecs.length) return;
+	const entries = [];
+	for (const { inner, open } of stringCodecs) {
+		const entry = captureInnerCodec(inner, open, sanitize);
+		if (!entry) break;
+		entries.push(entry);
+	}
+	return entries.length === stringCodecs.length ? entries : void 0;
+}
+
+//#endregion
+export { captureStringCodecEntries, reconstructInnerCodecs };

package/dist/type/validator/validator-cache.d.ts

@@ -0,0 +1,21 @@
+import { CoerceOption } from "../coerce.js";
+import { TSchema } from "typebox/type";
+import * as _$typebox_schema0 from "typebox/schema";
+import { Validator } from "typebox/schema";
+
+//#region src/type/validator/validator-cache.d.ts
+declare class TypeBoxValidatorCache {
+  #private;
+  private static EMPTY;
+  private static ignoreKeys;
+  private static fnIds;
+  private static nextFnId;
+  private static fnKey;
+  static ignoreMeta(k: string, v: unknown): any;
+  constructor(gcTime: number);
+  get(schema: TSchema, coercions?: CoerceOption[] | typeof TypeBoxValidatorCache.EMPTY, normalize?: string): Validator<_$typebox_schema0.XSchema, unknown> | undefined;
+  set(schema: TSchema, coercions?: CoerceOption[] | typeof TypeBoxValidatorCache.EMPTY, validator?: Validator, normalize?: string): void;
+  clear(): void;
+}
+//#endregion
+export { TypeBoxValidatorCache };

package/dist/type/validator/validator-cache.js

@@ -0,0 +1,163 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_universal_constants = require('../../universal/constants.js');
+const require_utils = require('../../utils.js');
+const require_type_constants = require('../constants.js');
+const require_type_coerce = require('../coerce.js');
+let typebox_value = require("typebox/value");
+
+//#region src/type/validator/validator-cache.ts
+const DEFAULT_CACHE_LIMIT = 1024;
+const DEFAULT_GC_TIME = 60 * 1e3;
+var TypeBoxValidatorCache = class TypeBoxValidatorCache {
+	static {
+		this.EMPTY = require_utils.nullObject();
+	}
+	static {
+		this.ignoreKeys = new Set([
+			"title",
+			"description",
+			"tags",
+			"examples",
+			"defaultValue"
+		]);
+	}
+	static {
+		this.fnIds = /* @__PURE__ */ new WeakMap();
+	}
+	static {
+		this.nextFnId = 0;
+	}
+	static fnKey(fn) {
+		let id = TypeBoxValidatorCache.fnIds.get(fn);
+		if (id === void 0) {
+			id = ++TypeBoxValidatorCache.nextFnId;
+			TypeBoxValidatorCache.fnIds.set(fn, id);
+		}
+		return `<fn:${id}>`;
+	}
+	static ignoreMeta(k, v) {
+		if (TypeBoxValidatorCache.ignoreKeys.has(k)) return;
+		if (typeof v === "function") return TypeBoxValidatorCache.fnKey(v);
+		if (v && typeof v === "object" && v["~optional"] === true) {
+			const out = require_utils.nullObject();
+			for (const key in v) out[key] = v[key];
+			out["~optional"] = true;
+			return out;
+		}
+		return v;
+	}
+	static #isOpaqueType(schema, seen = /* @__PURE__ */ new WeakSet()) {
+		if (!schema || typeof schema !== "object" || seen.has(schema)) return false;
+		seen.add(schema);
+		if (schema["~refine"] || schema["~elyTyp"] === require_type_constants.ELYSIA_TYPES.NoValidate) return true;
+		const props = schema.properties;
+		if (props) {
+			for (const k in props) if (TypeBoxValidatorCache.#isOpaqueType(props[k], seen)) return true;
+		}
+		const items = schema.items;
+		if (Array.isArray(items)) {
+			for (const it of items) if (TypeBoxValidatorCache.#isOpaqueType(it, seen)) return true;
+		} else if (items && TypeBoxValidatorCache.#isOpaqueType(items, seen)) return true;
+		for (const k of [
+			"anyOf",
+			"allOf",
+			"oneOf"
+		]) {
+			const arr = schema[k];
+			if (Array.isArray(arr)) {
+				for (const x of arr) if (TypeBoxValidatorCache.#isOpaqueType(x, seen)) return true;
+			}
+		}
+		if (schema.additionalProperties && typeof schema.additionalProperties === "object" && TypeBoxValidatorCache.#isOpaqueType(schema.additionalProperties, seen)) return true;
+		if (schema.not && TypeBoxValidatorCache.#isOpaqueType(schema.not, seen)) return true;
+		const pp = schema.patternProperties;
+		if (pp) {
+			for (const k in pp) if (TypeBoxValidatorCache.#isOpaqueType(pp[k], seen)) return true;
+		}
+		return false;
+	}
+	#cache = /* @__PURE__ */ new Map();
+	#referenceCache = /* @__PURE__ */ new WeakMap();
+	#gc;
+	#gcTime;
+	#lastSchema;
+	#lastMeta;
+	#meta(schema) {
+		if (this.#lastSchema === schema && this.#lastMeta) return this.#lastMeta;
+		const special = (0, typebox_value.HasCodec)(schema) || TypeBoxValidatorCache.#isOpaqueType(schema);
+		const meta = {
+			special,
+			key: special ? "" : JSON.stringify(schema, TypeBoxValidatorCache.ignoreMeta)
+		};
+		this.#lastSchema = schema;
+		this.#lastMeta = meta;
+		return meta;
+	}
+	constructor(gcTime) {
+		this.#gcTime = gcTime;
+	}
+	#scheduleClear() {
+		if (require_universal_constants.isCloudflareWorker) return;
+		if (this.#gc) clearTimeout(this.#gc);
+		this.#gc = setTimeout(() => this.clear(), this.#gcTime ?? DEFAULT_GC_TIME);
+		this.#gc.unref?.();
+	}
+	get(schema, coercions = TypeBoxValidatorCache.EMPTY, normalize = "") {
+		const refBucket = this.#referenceCache.get(schema)?.get(normalize);
+		if (refBucket?.has(coercions)) return refBucket.get(coercions);
+		const meta = this.#meta(schema);
+		if (meta.special) return;
+		const key = meta.key + "\0" + normalize;
+		if (this.#cache.has(key)) {
+			const coercionsCache = this.#cache.get(key);
+			this.#cache.delete(key);
+			this.#cache.set(key, coercionsCache);
+			if (coercionsCache.has(coercions)) return coercionsCache.get(coercions);
+		}
+	}
+	#refBucket(schema) {
+		let byNormalize = this.#referenceCache.get(schema);
+		if (!byNormalize) {
+			byNormalize = /* @__PURE__ */ new Map();
+			this.#referenceCache.set(schema, byNormalize);
+		}
+		return byNormalize;
+	}
+	set(schema, coercions = TypeBoxValidatorCache.EMPTY, validator, normalize = "") {
+		this.#scheduleClear();
+		const meta = this.#meta(schema);
+		if (meta.special) {
+			const cache = (/* @__PURE__ */ new WeakMap()).set(coercions, validator);
+			this.#refBucket(schema).set(normalize, cache);
+			return;
+		}
+		const key = meta.key + "\0" + normalize;
+		if (this.#cache.has(key)) {
+			const cache = this.#cache.get(key).set(coercions, validator);
+			const byNormalize = this.#refBucket(schema);
+			if (byNormalize.has(normalize)) byNormalize.get(normalize).set(coercions, validator);
+			else byNormalize.set(normalize, cache);
+			return;
+		}
+		if (this.#cache.size >= DEFAULT_CACHE_LIMIT) {
+			const oldest = this.#cache.keys().next().value;
+			if (oldest !== void 0) this.#cache.delete(oldest);
+		}
+		const cache = (/* @__PURE__ */ new WeakMap()).set(coercions, validator);
+		this.#cache.set(key, cache);
+		this.#refBucket(schema).set(normalize, cache);
+	}
+	clear() {
+		if (this.#gc) {
+			clearTimeout(this.#gc);
+			this.#gc = void 0;
+		}
+		this.#cache.clear();
+		this.#referenceCache = /* @__PURE__ */ new WeakMap();
+		require_type_coerce.deferCoercions();
+	}
+};
+
+//#endregion
+exports.TypeBoxValidatorCache = TypeBoxValidatorCache;

package/dist/type/validator/validator-cache.mjs

@@ -0,0 +1,161 @@
+import { isCloudflareWorker } from "../../universal/constants.mjs";
+import { nullObject } from "../../utils.mjs";
+import { ELYSIA_TYPES } from "../constants.mjs";
+import { deferCoercions } from "../coerce.mjs";
+import { HasCodec } from "typebox/value";
+
+//#region src/type/validator/validator-cache.ts
+const DEFAULT_CACHE_LIMIT = 1024;
+const DEFAULT_GC_TIME = 60 * 1e3;
+var TypeBoxValidatorCache = class TypeBoxValidatorCache {
+	static {
+		this.EMPTY = nullObject();
+	}
+	static {
+		this.ignoreKeys = new Set([
+			"title",
+			"description",
+			"tags",
+			"examples",
+			"defaultValue"
+		]);
+	}
+	static {
+		this.fnIds = /* @__PURE__ */ new WeakMap();
+	}
+	static {
+		this.nextFnId = 0;
+	}
+	static fnKey(fn) {
+		let id = TypeBoxValidatorCache.fnIds.get(fn);
+		if (id === void 0) {
+			id = ++TypeBoxValidatorCache.nextFnId;
+			TypeBoxValidatorCache.fnIds.set(fn, id);
+		}
+		return `<fn:${id}>`;
+	}
+	static ignoreMeta(k, v) {
+		if (TypeBoxValidatorCache.ignoreKeys.has(k)) return;
+		if (typeof v === "function") return TypeBoxValidatorCache.fnKey(v);
+		if (v && typeof v === "object" && v["~optional"] === true) {
+			const out = nullObject();
+			for (const key in v) out[key] = v[key];
+			out["~optional"] = true;
+			return out;
+		}
+		return v;
+	}
+	static #isOpaqueType(schema, seen = /* @__PURE__ */ new WeakSet()) {
+		if (!schema || typeof schema !== "object" || seen.has(schema)) return false;
+		seen.add(schema);
+		if (schema["~refine"] || schema["~elyTyp"] === ELYSIA_TYPES.NoValidate) return true;
+		const props = schema.properties;
+		if (props) {
+			for (const k in props) if (TypeBoxValidatorCache.#isOpaqueType(props[k], seen)) return true;
+		}
+		const items = schema.items;
+		if (Array.isArray(items)) {
+			for (const it of items) if (TypeBoxValidatorCache.#isOpaqueType(it, seen)) return true;
+		} else if (items && TypeBoxValidatorCache.#isOpaqueType(items, seen)) return true;
+		for (const k of [
+			"anyOf",
+			"allOf",
+			"oneOf"
+		]) {
+			const arr = schema[k];
+			if (Array.isArray(arr)) {
+				for (const x of arr) if (TypeBoxValidatorCache.#isOpaqueType(x, seen)) return true;
+			}
+		}
+		if (schema.additionalProperties && typeof schema.additionalProperties === "object" && TypeBoxValidatorCache.#isOpaqueType(schema.additionalProperties, seen)) return true;
+		if (schema.not && TypeBoxValidatorCache.#isOpaqueType(schema.not, seen)) return true;
+		const pp = schema.patternProperties;
+		if (pp) {
+			for (const k in pp) if (TypeBoxValidatorCache.#isOpaqueType(pp[k], seen)) return true;
+		}
+		return false;
+	}
+	#cache = /* @__PURE__ */ new Map();
+	#referenceCache = /* @__PURE__ */ new WeakMap();
+	#gc;
+	#gcTime;
+	#lastSchema;
+	#lastMeta;
+	#meta(schema) {
+		if (this.#lastSchema === schema && this.#lastMeta) return this.#lastMeta;
+		const special = HasCodec(schema) || TypeBoxValidatorCache.#isOpaqueType(schema);
+		const meta = {
+			special,
+			key: special ? "" : JSON.stringify(schema, TypeBoxValidatorCache.ignoreMeta)
+		};
+		this.#lastSchema = schema;
+		this.#lastMeta = meta;
+		return meta;
+	}
+	constructor(gcTime) {
+		this.#gcTime = gcTime;
+	}
+	#scheduleClear() {
+		if (isCloudflareWorker) return;
+		if (this.#gc) clearTimeout(this.#gc);
+		this.#gc = setTimeout(() => this.clear(), this.#gcTime ?? DEFAULT_GC_TIME);
+		this.#gc.unref?.();
+	}
+	get(schema, coercions = TypeBoxValidatorCache.EMPTY, normalize = "") {
+		const refBucket = this.#referenceCache.get(schema)?.get(normalize);
+		if (refBucket?.has(coercions)) return refBucket.get(coercions);
+		const meta = this.#meta(schema);
+		if (meta.special) return;
+		const key = meta.key + "\0" + normalize;
+		if (this.#cache.has(key)) {
+			const coercionsCache = this.#cache.get(key);
+			this.#cache.delete(key);
+			this.#cache.set(key, coercionsCache);
+			if (coercionsCache.has(coercions)) return coercionsCache.get(coercions);
+		}
+	}
+	#refBucket(schema) {
+		let byNormalize = this.#referenceCache.get(schema);
+		if (!byNormalize) {
+			byNormalize = /* @__PURE__ */ new Map();
+			this.#referenceCache.set(schema, byNormalize);
+		}
+		return byNormalize;
+	}
+	set(schema, coercions = TypeBoxValidatorCache.EMPTY, validator, normalize = "") {
+		this.#scheduleClear();
+		const meta = this.#meta(schema);
+		if (meta.special) {
+			const cache = (/* @__PURE__ */ new WeakMap()).set(coercions, validator);
+			this.#refBucket(schema).set(normalize, cache);
+			return;
+		}
+		const key = meta.key + "\0" + normalize;
+		if (this.#cache.has(key)) {
+			const cache = this.#cache.get(key).set(coercions, validator);
+			const byNormalize = this.#refBucket(schema);
+			if (byNormalize.has(normalize)) byNormalize.get(normalize).set(coercions, validator);
+			else byNormalize.set(normalize, cache);
+			return;
+		}
+		if (this.#cache.size >= DEFAULT_CACHE_LIMIT) {
+			const oldest = this.#cache.keys().next().value;
+			if (oldest !== void 0) this.#cache.delete(oldest);
+		}
+		const cache = (/* @__PURE__ */ new WeakMap()).set(coercions, validator);
+		this.#cache.set(key, cache);
+		this.#refBucket(schema).set(normalize, cache);
+	}
+	clear() {
+		if (this.#gc) {
+			clearTimeout(this.#gc);
+			this.#gc = void 0;
+		}
+		this.#cache.clear();
+		this.#referenceCache = /* @__PURE__ */ new WeakMap();
+		deferCoercions();
+	}
+};
+
+//#endregion
+export { TypeBoxValidatorCache };

package/dist/types.d.ts

@@ -4,14 +4,14 @@ import { CookieOptions } from "./cookie/types.js";
 import { ElysiaFile } from "./universal/file.js";
 import { TraceEvent, TraceListener } from "./trace.js";
 import { Serve } from "./universal/server.js";
-import { ElysiaAdapter } from "./adapter/index.js";
 import { AnySchema, StandardSchemaV1Like, TypeBoxSchema } from "./type/types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext, PreContext } from "./context.js";
 import { WebSocketHandler } from "./ws/types.js";
 import { AnyElysia, Elysia } from "./base.js";
-import { Instruction } from "exact-mirror";
+import { ElysiaAdapter } from "./adapter/index.js";
 import { Static, StaticDecode, StaticEncode, TIntersect, TObject, TSchema } from "typebox";
+import { Instruction } from "exact-mirror";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/types.d.ts
@@ -83,6 +83,12 @@ interface ElysiaConfig<in out Prefix extends string | undefined, in out Scope ex
    * @default false
    */
   strictPath?: boolean;
+  /**
+   * Whether should Elysia handle distinction between overlapping path
+   *
+   * @default false
+   */
+  distinctPath?: boolean;
   /**
    * Automatically register a HEAD handler for every GET route, deriving the
    * response headers (e.g. `content-length`) from the GET handler while
@@ -736,6 +742,18 @@ type MacroDefSchema<K, MBody, MHeaders, MQuery, MParams, MCookie> = {
   cookie: AsMacroSchemaField<K extends keyof MCookie ? MCookie[K] : undefined>;
   response: undefined;
 };
+/**
+ * Upper bound for a macro definition's schema channel (`body`/`headers`/…):
+ * a registered model name or an inline schema.
+ *
+ * Used as the `const Body extends …` constraint on `.macro()`. It does not
+ * restrict (valid inputs already satisfy it) — it stops `Body[K]` from being a
+ * bare `unknown`, which is what lets the `| Name` in the field surface model
+ * names to autocomplete (a `unknown | Name` union collapses to `unknown`).
+ * `const` still narrows `Body[K]` to the typed literal for `UnwrapRoute`.
+ */
+type MacroSchemaChannel<Definitions extends DefinitionBase> = Record<keyof any, AnySchema | (keyof Definitions['typebox'] & string)>;
+type MacroChannel<Channel, Key extends keyof InputSchema, Definitions extends DefinitionBase> = { [K in keyof Channel]: MaybeValueOrVoidFunction<{ [F in Key]?: Channel[K] | (keyof Definitions['typebox'] & string) } & Record<string, unknown>> };
 /**
  * Parameter type of the object-form `.macro({ name: definition })`
  *
@@ -748,17 +766,7 @@ type MacroDefSchema<K, MBody, MHeaders, MQuery, MParams, MCookie> = {
  * still flow into `N` (the verbatim definitions, stored in
  * `Metadata['macroFn']` for the consuming route)
  */
-type ObjectMacroDefs<Body, Headers, Query, Params, Cookie, N, AmbientSchema extends RouteSchema, ScopedSchemas extends RouteSchema, Singleton extends SingletonBase, Definitions extends DefinitionBase, MacroNames extends BaseMacro> = { [K in keyof Body]: MaybeValueOrVoidFunction<{
-  body?: Body[K];
-}> } & { [K in keyof Headers]: MaybeValueOrVoidFunction<{
-  headers?: Headers[K];
-}> } & { [K in keyof Query]: MaybeValueOrVoidFunction<{
-  query?: Query[K];
-}> } & { [K in keyof Params]: MaybeValueOrVoidFunction<{
-  params?: Params[K];
-}> } & { [K in keyof Cookie]: MaybeValueOrVoidFunction<{
-  cookie?: Cookie[K];
-}> } & { [K in keyof N]: MaybeValueOrVoidFunction<MacroProperty<MacroNames & InputSchema<keyof Definitions['typebox'] & string>, IntersectIfObjectSchema<MergeSchema<UnwrapMacroSchema<MacroDefSchema<K, Body, Headers, Query, Params, Cookie>, Definitions['typebox']>, AmbientSchema>, ScopedSchemas>, Singleton, Definitions['error']>> } & { [K in keyof N]: N[K] extends ((...a: any[]) => any) ? unknown : string extends keyof N[K] ? unknown : { [P in Exclude<keyof N[K], MacroPropertyKey | InputSchemaKey | keyof MacroNames | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
+type ObjectMacroDefs<Body, Headers, Query, Params, Cookie, N, AmbientSchema extends RouteSchema, ScopedSchemas extends RouteSchema, Singleton extends SingletonBase, Definitions extends DefinitionBase, MacroNames extends BaseMacro> = MacroChannel<Body, 'body', Definitions> & MacroChannel<Headers, 'headers', Definitions> & MacroChannel<Query, 'query', Definitions> & MacroChannel<Params, 'params', Definitions> & MacroChannel<Cookie, 'cookie', Definitions> & { [K in keyof N]: MaybeValueOrVoidFunction<MacroProperty<MacroNames & InputSchema<keyof Definitions['typebox'] & string>, IntersectIfObjectSchema<MergeSchema<UnwrapMacroSchema<MacroDefSchema<K, Body, Headers, Query, Params, Cookie>, Definitions['typebox']>, AmbientSchema>, ScopedSchemas>, Singleton, Definitions['error']>> } & { [K in keyof N]: N[K] extends ((...a: any[]) => any) ? unknown : string extends keyof N[K] ? unknown : { [P in Exclude<keyof N[K], MacroPropertyKey | InputSchemaKey | keyof MacroNames | keyof N>]: `Unknown macro property '${P & string}'` } } & N;
 type CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `/${infer Rest}` ? _CreateEden<Rest, Property> : Path extends '' | '/' ? Property : _CreateEden<Path, Property>;
 type _CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `${infer Start}/${infer Rest}` ? { [x in Start]: _CreateEden<Rest, Property> } : Path extends '' ? Property : { [x in Path]: Property };
 type CreateEdenResponse<Path extends string, Schema extends RouteSchema, MacroContext extends RouteSchema, Res extends PossibleResponse, Err extends Error = never> = RouteSchema extends MacroContext ? {
@@ -877,4 +885,4 @@ type AddWSRoute<BasePath extends string, Scope extends EventScope, Singleton ext
   subscribe: CreateWSEdenResponse<Path, Schema, MacroContext, ComposeElysiaResponse<Schema & MacroContext & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], Response, UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], UnionResponseStatus<Volatile['response'], MacroContext['return'] & {}>>>, [...Definitions['error'], ...Ephemeral['error'], ...Volatile['error']]>>;
 }>, Ephemeral, Volatile>;
 //#endregion
-export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GracefulHandler, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, Handler, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InlineSchemaResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, IsUnknown, JoinPath, LocalHook, Macro, MacroProperty, MacroPropertyKey, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, RouteBase, RouteSchema, SSEPayload, SingletonBase, TraceHandler, TransformHandler, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WrapFn };
+export { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, type AnySchema, AnyWSLocalHook, AppEvent, AppHook, BaseMacro, BodyHandler, BunHTMLBundlelike, CompiledHandler, ComposeElysiaResponse, ContentType, ContextAppendType, CreateEden, CreateEdenResponse, CreateWSEdenResponse, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaFormData, ElysiaHandlerToResponseSchema, ElysiaHandlerToResponseSchemaAmbiguous, ElysiaHandlerToResponseSchemas, EmptyInputSchema, EphemeralType, Equal, ErrorDefinition, ErrorDefinitionEntry, ErrorHandler, ErrorHandlerResponseSchema, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, ExtractReturnedError, GetPathParameter, GracefulHandler, GuardLocalHook, GuardSchemaType, HTTPHeaders, HTTPMethod, Handler, InlineHandler, InlineHandlerNonMacro, InlineHandlerResponse, InlineResponse, InlineSchemaResponse, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObject, IntersectIfObjectSchema, IsAny, IsNever, IsTuple, IsUnknown, JoinPath, LocalHook, Macro, MacroProperty, MacroPropertyKey, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MaybeValueOrVoidFunction, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PossibleResponse, PreHandler, Prettify, PublicRoute, Replace, ResolveHandler, ResolvePath, ResolveRouteErrors, RouteBase, RouteSchema, SSEPayload, SingletonBase, type StandardSchemaV1Like, TraceHandler, TransformHandler, type TypeBoxSchema, UnhandledReturnedError, UnhandledReturnedErrorOf, UnionResponseStatus, UnionToIntersect, UnwrapArray, UnwrapBodySchema, UnwrapMacroSchema, UnwrapRoute, UnwrapSchema, ValueOrFunctionToResponseSchema, ValueToResponseSchema, VoidHandler, WrapFn };

package/dist/universal/file.d.ts

@@ -36,7 +36,7 @@ declare const mime: {
   readonly ppt: "application/vnd.ms-powerpoint";
   readonly pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
 };
-declare const getFileExtension: (path: string) => string;
+declare function getFileExtension(path: string): string;
 declare const file: (path: string) => ElysiaFile;
 declare class ElysiaFile {
   path: string;

package/dist/universal/file.js

@@ -2,22 +2,26 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('./constants.js');
 
 //#region src/universal/file.ts
+const text = "text/";
+const application = "application/";
+const image = "image/";
+const msft365 = "application/vnd.openxmlformats-officedocument.";
 const mime = {
-	html: "text/html",
-	htm: "text/html",
-	css: "text/css",
-	js: "application/javascript",
-	ts: "application/typescript",
-	json: "application/json",
-	xml: "application/xml",
-	jpg: "image/jpeg",
-	jpeg: "image/jpeg",
-	png: "image/png",
-	gif: "image/gif",
-	webp: "image/webp",
-	avif: "image/avif",
-	svg: "image/svg+xml",
-	ico: "image/x-icon",
+	html: `${text}html`,
+	htm: `${text}html`,
+	css: `${text}css`,
+	js: `${application}javascript`,
+	ts: `${application}typescript`,
+	json: `${application}json`,
+	xml: `${application}xml`,
+	jpg: `${image}jpeg`,
+	jpeg: `${image}jpeg`,
+	png: `${image}png`,
+	gif: `${image}gif`,
+	webp: `${image}webp`,
+	avif: `${image}avif`,
+	svg: `${image}svg+xml`,
+	ico: `${image}x-icon`,
 	mp4: "video/mp4",
 	webm: "video/webm",
 	mp3: "audio/mpeg",
@@ -26,26 +30,28 @@ const mime = {
 	woff2: "font/woff2",
 	ttf: "font/ttf",
 	otf: "font/otf",
-	pdf: "application/pdf",
-	txt: "text/plain",
-	csv: "text/csv",
-	zip: "application/zip",
-	doc: "application/msword",
-	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-	xls: "application/vnd.ms-excel",
-	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-	ppt: "application/vnd.ms-powerpoint",
-	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+	pdf: `${application}pdf`,
+	txt: `${text}plain`,
+	csv: `${text}csv`,
+	zip: `${application}zip`,
+	doc: `${application}msword`,
+	docx: `${msft365}wordprocessingml.document`,
+	xls: `${application}vnd.ms-excel`,
+	xlsx: `${msft365}spreadsheetml.sheet`,
+	ppt: `${application}vnd.ms-powerpoint`,
+	pptx: `${msft365}presentationml.presentation`
 };
-const getFileExtension = (path) => {
+function getFileExtension(path) {
 	const index = path.lastIndexOf(".");
 	if (index === -1) return "";
-	return path.slice(index + 1);
-};
+	return path.slice(index + 1).toLowerCase();
+}
 const file = (path) => new ElysiaFile(path);
 let createReadStream;
 let stat;
-const warnMissing = (name) => console.warn(/* @__PURE__ */ new Error(`[elysia] \`file\` require \`fs${name ? "." + name : ""}\` ${name?.includes(".") ? "module " : ""}which is not available in this environment`));
+function warnMissing(name) {
+	console.warn(/* @__PURE__ */ new Error(`[Elysia] \`file\` require \`fs${name ? "." + name : ""}\` ${name?.includes(".") ? "module " : ""}which is not available in this environment`));
+}
 var ElysiaFile = class {
 	constructor(path) {
 		this.path = path;