clear-router 2.8.9 → 2.9.1

package/dist/h3/router.d.cts

@@ -15,6 +15,7 @@ import { H3 } from "h3";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static readBodyCached;

package/dist/h3/router.d.mts

@@ -15,6 +15,7 @@ import { H3 } from "h3";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static readBodyCached;

package/dist/h3/router.mjs

@@ -11,6 +11,9 @@ import { HTTPResponse, getQuery, getRouterParams, readBody } from "h3";
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:h3";
+	static formatWildcardParam(name) {
+		return `**:${name}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static toResponse(ctx, value, method, path) {
 		const meta = resolveResponseMeta(value, {
@@ -205,17 +208,20 @@ var Router = class Router extends CoreRouter {
 					console.error("[ROUTES]", error.message);
 					throw error;
 				}
-				for (const registrationPath of route.registrationPaths) app[method](registrationPath, async (event) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app[method](registrationPath, async (event) => {
 					try {
 						const ctx = event;
 						const reqBody = await Router.readBodyCached(ctx);
 						const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody);
 						if (method === "post" && override && override !== "post") return;
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, getRouterParams(ctx, { decode: true }));
+						if (params === false) return Symbol.for("h3.notFound");
+						ctx.context = Object.assign(ctx.context ?? {}, { params });
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: reqBody,
 							query: getQuery(ctx),
-							params: getRouterParams(ctx, { decode: true }),
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -230,16 +236,19 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.post(registrationPath, async (event) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.post(registrationPath, async (event) => {
 					try {
 						const ctx = event;
 						const reqBody = await Router.readBodyCached(ctx);
 						if (Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody) !== method) return Symbol.for("h3.notFound");
 						const inst = instance ?? route;
+						const params = Router.matchRoute(route, ctx, getRouterParams(ctx, { decode: true }));
+						if (params === false) return Symbol.for("h3.notFound");
+						ctx.context = Object.assign(ctx.context ?? {}, { params });
 						Router.bindRequestToInstance(ctx, inst, route, {
 							body: reqBody,
 							query: getQuery(ctx),
-							params: getRouterParams(ctx, { decode: true }),
+							params,
 							method
 						});
 						const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/hono/router.cjs

@@ -10,6 +10,9 @@ const require_responses = require('../core/responses.cjs');
 */
 var Router = class Router extends require_CoreRouter.CoreRouter {
 	static routerStateNamespace = "clear-router:hono";
+	static formatWildcardParam(name) {
+		return `:${name}{.+}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static toResponse(ctx, value, method, path) {
 		const meta = require_responses.resolveResponseMeta(value, {
@@ -204,16 +207,18 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) app[method](registrationPath, ...route.middlewares || [], async (context) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app[method](registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody);
 					if (method === "post" && override && override !== "post") return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -225,15 +230,17 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.post(registrationPath, ...route.middlewares || [], async (context) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.post(registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody) !== method) return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/hono/router.d.cts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.cjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static getParams;

package/dist/hono/router.d.mts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.mjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static toResponse;
   private static getParams;

package/dist/hono/router.mjs

@@ -10,6 +10,9 @@ import { resolveResponseMeta } from "../core/responses.mjs";
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:hono";
+	static formatWildcardParam(name) {
+		return `:${name}{.+}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static toResponse(ctx, value, method, path) {
 		const meta = resolveResponseMeta(value, {
@@ -204,16 +207,18 @@ var Router = class Router extends CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) app[method](registrationPath, ...route.middlewares || [], async (context) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) app[method](registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody);
 					if (method === "post" && override && override !== "post") return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -225,15 +230,17 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) app.post(registrationPath, ...route.middlewares || [], async (context) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) app.post(registrationPath, ...route.middlewares || [], async (context) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.req.method, ctx.req.header(), reqBody) !== method) return;
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, Router.getParams(ctx));
+					if (params === false) return ctx.notFound();
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.req.query(),
-						params: Router.getParams(ctx),
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/index.cjs

@@ -4,9 +4,11 @@ const require_Controller = require('./Controller.cjs');
 const require_Route = require('./Route.cjs');
 const require_helpers = require('./core/helpers.cjs');
 const require_RouteGroup = require('./RouteGroup.cjs');
+const require_RouteRegistrar = require('./RouteRegistrar.cjs');
 const require_Request = require('./core/Request.cjs');
 const require_Response = require('./core/Response.cjs');
 const require_plugins = require('./core/plugins.cjs');
+const require_middleware = require('./decorators/middleware.cjs');
 const require_CoreRouter = require('./core/CoreRouter.cjs');
 require('./core/index.cjs');
 
@@ -17,6 +19,10 @@ exports.Request = require_Request.Request;
 exports.Response = require_Response.Response;
 exports.Route = require_Route.Route;
 exports.RouteGroup = require_RouteGroup.RouteGroup;
+exports.RouteRegistrar = require_RouteRegistrar.RouteRegistrar;
 exports.definePlugin = require_plugins.definePlugin;
+exports.getControllerMiddlewares = require_middleware.getControllerMiddlewares;
 exports.importFile = require_helpers.importFile;
+exports.middleware = require_middleware.middleware;
+exports.parseDomainParameters = require_Route.parseDomainParameters;
 exports.wrap = require_helpers.wrap;

package/dist/index.d.cts

@@ -1,11 +1,13 @@
 import { ClearHttpContext, RouteParameter } from "./Contracts.cjs";
 import { Response } from "./core/Response.cjs";
 import { ClearRequest } from "./ClearRequest.cjs";
-import { Route } from "./Route.cjs";
+import { Route, parseDomainParameters } from "./Route.cjs";
 import { Request } from "./core/Request.cjs";
 import { ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, definePlugin } from "./core/plugins.cjs";
+import { MiddlewareDecorator, MiddlewareInput, getControllerMiddlewares, middleware } from "./decorators/middleware.cjs";
 import { Controller } from "./Controller.cjs";
 import { RouteGroup } from "./RouteGroup.cjs";
+import { RouteRegistrar, RouteRegistrarGroupFactory } from "./RouteRegistrar.cjs";
 import { CoreRouter } from "./core/CoreRouter.cjs";
 import { importFile, wrap } from "./core/helpers.cjs";
-export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, definePlugin, importFile, wrap };
+export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, MiddlewareDecorator, MiddlewareInput, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, RouteRegistrar, RouteRegistrarGroupFactory, definePlugin, getControllerMiddlewares, importFile, middleware, parseDomainParameters, wrap };

package/dist/index.d.mts

@@ -1,12 +1,13 @@
 import { ClearHttpContext, RouteParameter } from "./Contracts.mjs";
 import { Response } from "./core/Response.mjs";
 import { ClearRequest } from "./ClearRequest.mjs";
-import { Route } from "./Route.mjs";
+import { Route, parseDomainParameters } from "./Route.mjs";
 import { Request } from "./core/Request.mjs";
 import { ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, definePlugin } from "./core/plugins.mjs";
+import { MiddlewareDecorator, MiddlewareInput, getControllerMiddlewares, middleware } from "./decorators/middleware.mjs";
 import { Controller } from "./Controller.mjs";
 import { RouteGroup } from "./RouteGroup.mjs";
+import { RouteRegistrar, RouteRegistrarGroupFactory } from "./RouteRegistrar.mjs";
 import { CoreRouter } from "./core/CoreRouter.mjs";
 import { importFile, wrap } from "./core/helpers.mjs";
-import "./core/index.mjs";
-export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, definePlugin, importFile, wrap };
+export { ClearHttpContext, ClearRequest, ClearRouterPlugin, ClearRouterPluginArgumentsContext, ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, Controller, CoreRouter, MiddlewareDecorator, MiddlewareInput, PluginArgumentsResolver, PluginBind, PluginBindFactory, PluginBindValue, PluginSetupResult, Request, Response, Route, RouteGroup, RouteParameter, RouteRegistrar, RouteRegistrarGroupFactory, definePlugin, getControllerMiddlewares, importFile, middleware, parseDomainParameters, wrap };

package/dist/index.mjs

@@ -1,12 +1,14 @@
 import { ClearRequest } from "./ClearRequest.mjs";
 import { Controller } from "./Controller.mjs";
-import { Route } from "./Route.mjs";
+import { Route, parseDomainParameters } from "./Route.mjs";
 import { importFile, wrap } from "./core/helpers.mjs";
 import { RouteGroup } from "./RouteGroup.mjs";
+import { RouteRegistrar } from "./RouteRegistrar.mjs";
 import { Request } from "./core/Request.mjs";
 import { Response } from "./core/Response.mjs";
 import { definePlugin } from "./core/plugins.mjs";
+import { getControllerMiddlewares, middleware } from "./decorators/middleware.mjs";
 import { CoreRouter } from "./core/CoreRouter.mjs";
 import "./core/index.mjs";
 
-export { ClearRequest, Controller, CoreRouter, Request, Response, Route, RouteGroup, definePlugin, importFile, wrap };
+export { ClearRequest, Controller, CoreRouter, Request, Response, Route, RouteGroup, RouteRegistrar, definePlugin, getControllerMiddlewares, importFile, middleware, parseDomainParameters, wrap };

package/dist/koa/router.cjs

@@ -10,6 +10,9 @@ const require_responses = require('../core/responses.cjs');
 */
 var Router = class Router extends require_CoreRouter.CoreRouter {
 	static routerStateNamespace = "clear-router:koa";
+	static formatWildcardParam(name) {
+		return `*${name}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static async readBodyCached(ctx) {
 		if (this.bodyCache.has(ctx)) {
@@ -214,16 +217,19 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody);
 					if (method === "post" && override && override !== "post") return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -235,15 +241,18 @@ var Router = class Router extends require_CoreRouter.CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody) !== method) return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/koa/router.d.cts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.cjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static readBodyCached;
   private static readBody;

package/dist/koa/router.d.mts

@@ -14,6 +14,7 @@ import { CoreRouter } from "../core/CoreRouter.mjs";
  */
 declare class Router extends CoreRouter {
   protected static routerStateNamespace: string;
+  protected static formatWildcardParam(name: string): string;
   private static readonly bodyCache;
   private static readBodyCached;
   private static readBody;

package/dist/koa/router.mjs

@@ -10,6 +10,9 @@ import { isFetchResponse, resolveResponseMeta } from "../core/responses.mjs";
 */
 var Router = class Router extends CoreRouter {
 	static routerStateNamespace = "clear-router:koa";
+	static formatWildcardParam(name) {
+		return `*${name}`;
+	}
 	static bodyCache = /* @__PURE__ */ new WeakMap();
 	static async readBodyCached(ctx) {
 		if (this.bodyCache.has(ctx)) {
@@ -214,16 +217,19 @@ var Router = class Router extends CoreRouter {
 				];
 				if (method === "options" && route.methods.length > 1) continue;
 				if (!allowedMethods.includes(method)) throw new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-				for (const registrationPath of route.registrationPaths) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
+				for (const registrationPath of this.resolveRegistrationPaths(route)) router[method](registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					const override = Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody);
 					if (method === "post" && override && override !== "post") return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
@@ -235,15 +241,18 @@ var Router = class Router extends CoreRouter {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) for (const registrationPath of route.registrationPaths) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
+				].includes(method)) for (const registrationPath of this.resolveRegistrationPaths(route)) router.post(registrationPath, ...route.middlewares || [], async (context, next) => {
 					const ctx = context;
 					const reqBody = await Router.readBodyCached(ctx);
 					if (Router.resolveMethodOverride(ctx.method, ctx.headers, reqBody) !== method) return next();
 					const inst = instance ?? route;
+					const params = Router.matchRoute(route, ctx, ctx.params ?? {});
+					if (params === false) return next();
+					Object.assign(ctx.params ??= {}, params);
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {},
+						params,
 						method
 					});
 					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);

package/dist/types/basic.d.cts

@@ -79,12 +79,14 @@ type ResourceRoutesOptions<M = any> = {
 interface RouteGroupContext {
   prefix: string;
   groupMiddlewares: any[];
+  domain?: string;
   routeCollectors?: Array<Set<Route<any, any, any>>>;
 }
 interface RouteGroupOptions<S extends RouteGroupSource = RouteGroupSource> {
   prefix: string;
   source: S;
   middlewares?: any[];
+  domain?: string;
   context: AsyncLocalStorage<RouteGroupContext>;
   defaultPrefix: string;
   defaultMiddlewares: any[];

package/dist/types/basic.d.mts

@@ -79,12 +79,14 @@ type ResourceRoutesOptions<M = any> = {
 interface RouteGroupContext {
   prefix: string;
   groupMiddlewares: any[];
+  domain?: string;
   routeCollectors?: Array<Set<Route<any, any, any>>>;
 }
 interface RouteGroupOptions<S extends RouteGroupSource = RouteGroupSource> {
   prefix: string;
   source: S;
   middlewares?: any[];
+  domain?: string;
   context: AsyncLocalStorage<RouteGroupContext>;
   defaultPrefix: string;
   defaultMiddlewares: any[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clear-router",
-  "version": "2.8.9",
+  "version": "2.9.1",
   "description": "Laravel-style routing for Node.js with support for Express, H3, Fastify, Hono, and Koa, including CommonJS, ESM, and TypeScript support.",
   "keywords": [
     "h3",