@carno.js/core 0.2.11 → 1.0.2

package/dist/container/Container.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var Container_exports = {};
+__export(Container_exports, {
+  Container: () => Container,
+  Scope: () => Scope
+});
+module.exports = __toCommonJS(Container_exports);
+var Scope = /* @__PURE__ */ ((Scope2) => (Scope2.SINGLETON = "singleton", Scope2.REQUEST = "request", Scope2.INSTANCE = "instance", Scope2))(Scope || {});
+class Container {
+  constructor() {
+    this.configs = /* @__PURE__ */ new Map();
+    this.instances = /* @__PURE__ */ new Map();
+    this.resolving = /* @__PURE__ */ new Set();
+  }
+  register(config) {
+    const normalized = this.normalizeConfig(config);
+    return this.configs.set(normalized.token, normalized), normalized.useValue !== void 0 && this.instances.set(normalized.token, normalized.useValue), this;
+  }
+  get(token) {
+    const cached = this.instances.get(token);
+    return cached !== void 0 ? cached : this.resolveInternal(token).instance;
+  }
+  has(token) {
+    return this.configs.has(token);
+  }
+  /**
+   * Resolves a token to return instance and its effective scope.
+   */
+  resolveInternal(token, requestLocals) {
+    if (requestLocals?.has(token))
+      return { instance: requestLocals.get(token), scope: "request" /* REQUEST */ };
+    const cached = this.instances.get(token);
+    if (cached !== void 0)
+      return { instance: cached, scope: "singleton" /* SINGLETON */ };
+    const config = this.configs.get(token);
+    if (!config)
+      throw new Error(`Provider not found: ${token.name}`);
+    const creation = this.createInstance(config, requestLocals);
+    return creation.scope === "singleton" /* SINGLETON */ ? this.instances.set(token, creation.instance) : creation.scope === "request" /* REQUEST */ && requestLocals && requestLocals.set(token, creation.instance), creation;
+  }
+  createInstance(config, requestLocals) {
+    const target = config.useClass ?? config.token;
+    if (this.resolving.has(target))
+      throw new Error(`Circular dependency detected: ${target.name}`);
+    this.resolving.add(target);
+    try {
+      const depsToken = this.getDependencies(target);
+      if (depsToken.length === 0)
+        return { instance: new target(), scope: config.scope || "singleton" /* SINGLETON */ };
+      const args = [];
+      let effectiveScope = config.scope || "singleton" /* SINGLETON */;
+      for (const depToken of depsToken) {
+        const depResult = this.resolveInternal(depToken, requestLocals);
+        args.push(depResult.instance), depResult.scope === "request" /* REQUEST */ && effectiveScope === "singleton" /* SINGLETON */ && (effectiveScope = "request" /* REQUEST */);
+      }
+      return { instance: new target(...args), scope: effectiveScope };
+    } finally {
+      this.resolving.delete(target);
+    }
+  }
+  getDependencies(target) {
+    return (Reflect.getMetadata("design:paramtypes", target) || []).filter((t) => t && typeof t == "function" && !this.isPrimitive(t));
+  }
+  isPrimitive(type) {
+    return type === String || type === Number || type === Boolean || type === Object || type === Array || type === Symbol;
+  }
+  normalizeConfig(config) {
+    return typeof config == "function" ? {
+      token: config,
+      useClass: config,
+      scope: "singleton" /* SINGLETON */
+    } : {
+      ...config,
+      useClass: config.useClass ?? config.token,
+      scope: config.scope ?? "singleton" /* SINGLETON */
+    };
+  }
+  clear() {
+    this.configs.clear(), this.instances.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Container,
+  Scope
+});

package/dist/container/Container.mjs

@@ -0,0 +1,78 @@
+var Scope = /* @__PURE__ */ ((Scope2) => (Scope2.SINGLETON = "singleton", Scope2.REQUEST = "request", Scope2.INSTANCE = "instance", Scope2))(Scope || {});
+class Container {
+  constructor() {
+    this.configs = /* @__PURE__ */ new Map();
+    this.instances = /* @__PURE__ */ new Map();
+    this.resolving = /* @__PURE__ */ new Set();
+  }
+  register(config) {
+    const normalized = this.normalizeConfig(config);
+    return this.configs.set(normalized.token, normalized), normalized.useValue !== void 0 && this.instances.set(normalized.token, normalized.useValue), this;
+  }
+  get(token) {
+    const cached = this.instances.get(token);
+    return cached !== void 0 ? cached : this.resolveInternal(token).instance;
+  }
+  has(token) {
+    return this.configs.has(token);
+  }
+  /**
+   * Resolves a token to return instance and its effective scope.
+   */
+  resolveInternal(token, requestLocals) {
+    if (requestLocals?.has(token))
+      return { instance: requestLocals.get(token), scope: "request" /* REQUEST */ };
+    const cached = this.instances.get(token);
+    if (cached !== void 0)
+      return { instance: cached, scope: "singleton" /* SINGLETON */ };
+    const config = this.configs.get(token);
+    if (!config)
+      throw new Error(`Provider not found: ${token.name}`);
+    const creation = this.createInstance(config, requestLocals);
+    return creation.scope === "singleton" /* SINGLETON */ ? this.instances.set(token, creation.instance) : creation.scope === "request" /* REQUEST */ && requestLocals && requestLocals.set(token, creation.instance), creation;
+  }
+  createInstance(config, requestLocals) {
+    const target = config.useClass ?? config.token;
+    if (this.resolving.has(target))
+      throw new Error(`Circular dependency detected: ${target.name}`);
+    this.resolving.add(target);
+    try {
+      const depsToken = this.getDependencies(target);
+      if (depsToken.length === 0)
+        return { instance: new target(), scope: config.scope || "singleton" /* SINGLETON */ };
+      const args = [];
+      let effectiveScope = config.scope || "singleton" /* SINGLETON */;
+      for (const depToken of depsToken) {
+        const depResult = this.resolveInternal(depToken, requestLocals);
+        args.push(depResult.instance), depResult.scope === "request" /* REQUEST */ && effectiveScope === "singleton" /* SINGLETON */ && (effectiveScope = "request" /* REQUEST */);
+      }
+      return { instance: new target(...args), scope: effectiveScope };
+    } finally {
+      this.resolving.delete(target);
+    }
+  }
+  getDependencies(target) {
+    return (Reflect.getMetadata("design:paramtypes", target) || []).filter((t) => t && typeof t == "function" && !this.isPrimitive(t));
+  }
+  isPrimitive(type) {
+    return type === String || type === Number || type === Boolean || type === Object || type === Array || type === Symbol;
+  }
+  normalizeConfig(config) {
+    return typeof config == "function" ? {
+      token: config,
+      useClass: config,
+      scope: "singleton" /* SINGLETON */
+    } : {
+      ...config,
+      useClass: config.useClass ?? config.token,
+      scope: config.scope ?? "singleton" /* SINGLETON */
+    };
+  }
+  clear() {
+    this.configs.clear(), this.instances.clear();
+  }
+}
+export {
+  Container,
+  Scope
+};

package/dist/context/Context.js

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var Context_exports = {};
+__export(Context_exports, {
+  Context: () => Context
+});
+module.exports = __toCommonJS(Context_exports);
+const EMPTY_PARAMS = Object.freeze({});
+class Context {
+  constructor(req, params = EMPTY_PARAMS) {
+    this.locals = {};
+    // Lazy fields - only allocated when accessed
+    this._query = null;
+    this._bodyParsed = !1;
+    this._url = null;
+    this._status = 0;
+    this.req = req, this.params = params;
+  }
+  get status() {
+    return this._status || 200;
+  }
+  set status(value) {
+    this._status = value;
+  }
+  get url() {
+    return this._url || (this._url = new URL(this.req.url)), this._url;
+  }
+  get query() {
+    return this._query || (this._query = Object.fromEntries(this.url.searchParams)), this._query;
+  }
+  get body() {
+    return this._body;
+  }
+  async parseBody() {
+    if (this._bodyParsed)
+      return this._body;
+    this._bodyParsed = !0;
+    const contentType = this.req.headers.get("content-type") || "";
+    if (contentType.includes("application/json"))
+      this._body = await this.req.json();
+    else if (contentType.includes("form")) {
+      const formData = await this.req.formData();
+      this._body = Object.fromEntries(formData);
+    } else contentType.includes("text") ? this._body = await this.req.text() : this._body = await this.req.arrayBuffer();
+    return this._body;
+  }
+  get method() {
+    return this.req.method;
+  }
+  get headers() {
+    return this.req.headers;
+  }
+  get path() {
+    return this.url.pathname;
+  }
+  json(data, status) {
+    return status && (this.status = status), Response.json(data, { status: this.status });
+  }
+  text(data, status) {
+    return status && (this.status = status), new Response(data, {
+      status: this.status,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+  html(data, status) {
+    return status && (this.status = status), new Response(data, {
+      status: this.status,
+      headers: { "Content-Type": "text/html" }
+    });
+  }
+  redirect(url, status = 302) {
+    return Response.redirect(url, status);
+  }
+  /**
+   * Creates a Context from a job (for queue processing).
+   */
+  static createFromJob(job) {
+    const fakeRequest = new Request("http://localhost/job"), ctx = new Context(fakeRequest);
+    return ctx.locals.job = job, ctx;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context
+});

package/dist/context/Context.mjs

@@ -0,0 +1,77 @@
+const EMPTY_PARAMS = Object.freeze({});
+class Context {
+  constructor(req, params = EMPTY_PARAMS) {
+    this.locals = {};
+    // Lazy fields - only allocated when accessed
+    this._query = null;
+    this._bodyParsed = !1;
+    this._url = null;
+    this._status = 0;
+    this.req = req, this.params = params;
+  }
+  get status() {
+    return this._status || 200;
+  }
+  set status(value) {
+    this._status = value;
+  }
+  get url() {
+    return this._url || (this._url = new URL(this.req.url)), this._url;
+  }
+  get query() {
+    return this._query || (this._query = Object.fromEntries(this.url.searchParams)), this._query;
+  }
+  get body() {
+    return this._body;
+  }
+  async parseBody() {
+    if (this._bodyParsed)
+      return this._body;
+    this._bodyParsed = !0;
+    const contentType = this.req.headers.get("content-type") || "";
+    if (contentType.includes("application/json"))
+      this._body = await this.req.json();
+    else if (contentType.includes("form")) {
+      const formData = await this.req.formData();
+      this._body = Object.fromEntries(formData);
+    } else contentType.includes("text") ? this._body = await this.req.text() : this._body = await this.req.arrayBuffer();
+    return this._body;
+  }
+  get method() {
+    return this.req.method;
+  }
+  get headers() {
+    return this.req.headers;
+  }
+  get path() {
+    return this.url.pathname;
+  }
+  json(data, status) {
+    return status && (this.status = status), Response.json(data, { status: this.status });
+  }
+  text(data, status) {
+    return status && (this.status = status), new Response(data, {
+      status: this.status,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+  html(data, status) {
+    return status && (this.status = status), new Response(data, {
+      status: this.status,
+      headers: { "Content-Type": "text/html" }
+    });
+  }
+  redirect(url, status = 302) {
+    return Response.redirect(url, status);
+  }
+  /**
+   * Creates a Context from a job (for queue processing).
+   */
+  static createFromJob(job) {
+    const fakeRequest = new Request("http://localhost/job"), ctx = new Context(fakeRequest);
+    return ctx.locals.job = job, ctx;
+  }
+}
+export {
+  Context
+};

package/dist/cors/CorsHandler.js

@@ -0,0 +1,90 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var CorsHandler_exports = {};
+__export(CorsHandler_exports, {
+  CorsHandler: () => CorsHandler,
+  DEFAULT_CORS_HEADERS: () => DEFAULT_CORS_HEADERS,
+  DEFAULT_CORS_METHODS: () => DEFAULT_CORS_METHODS
+});
+module.exports = __toCommonJS(CorsHandler_exports);
+const DEFAULT_CORS_METHODS = ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"], DEFAULT_CORS_HEADERS = ["Content-Type", "Authorization", "X-Requested-With", "Accept", "Origin"];
+class CorsHandler {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    // Pre-created preflight response for wildcard CORS
+    this.preflightResponse = null;
+    this.methodsStr = (config.methods || DEFAULT_CORS_METHODS).join(", "), this.headersStr = (config.allowedHeaders || DEFAULT_CORS_HEADERS).join(", "), this.exposedStr = config.exposedHeaders?.join(", ") || null, this.maxAgeStr = config.maxAge?.toString() || null, this.hasCredentials = !!config.credentials, this.isWildcard = config.origins === "*", this.matcher = this.buildMatcher(config.origins), this.isWildcard && (this.preflightResponse = new Response(null, {
+      status: 204,
+      headers: this.buildHeaders("*")
+    }));
+  }
+  /**
+   * Handle preflight (OPTIONS) request.
+   */
+  preflight(origin) {
+    return this.isWildcard && this.preflightResponse ? this.preflightResponse.clone() : this.isAllowed(origin) ? new Response(null, {
+      status: 204,
+      headers: this.getHeaders(origin)
+    }) : new Response(null, { status: 403 });
+  }
+  /**
+   * Apply CORS headers to a response.
+   */
+  apply(response, origin) {
+    if (!this.isAllowed(origin))
+      return response;
+    const headers = this.getHeaders(origin);
+    for (const [key, value] of Object.entries(headers))
+      response.headers.set(key, value);
+    return response;
+  }
+  /**
+   * Check if origin is allowed.
+   */
+  isAllowed(origin) {
+    return this.matcher(origin);
+  }
+  /**
+   * Get cached CORS headers for origin.
+   */
+  getHeaders(origin) {
+    const key = this.isWildcard ? "*" : origin;
+    let headers = this.cache.get(key);
+    return headers || (headers = this.buildHeaders(origin), this.cache.set(key, headers)), headers;
+  }
+  buildHeaders(origin) {
+    const headers = {
+      "Access-Control-Allow-Origin": this.isWildcard ? "*" : origin,
+      "Access-Control-Allow-Methods": this.methodsStr,
+      "Access-Control-Allow-Headers": this.headersStr
+    };
+    return this.hasCredentials && (headers["Access-Control-Allow-Credentials"] = "true"), this.exposedStr && (headers["Access-Control-Expose-Headers"] = this.exposedStr), this.maxAgeStr && (headers["Access-Control-Max-Age"] = this.maxAgeStr), headers;
+  }
+  buildMatcher(origins) {
+    if (origins === "*") return () => !0;
+    if (typeof origins == "string") return (o) => o === origins;
+    if (Array.isArray(origins)) {
+      const set = new Set(origins);
+      return (o) => set.has(o);
+    }
+    return origins instanceof RegExp ? (o) => origins.test(o) : typeof origins == "function" ? origins : () => !1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CorsHandler,
+  DEFAULT_CORS_HEADERS,
+  DEFAULT_CORS_METHODS
+});

package/dist/cors/CorsHandler.mjs

@@ -0,0 +1,68 @@
+const DEFAULT_CORS_METHODS = ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"], DEFAULT_CORS_HEADERS = ["Content-Type", "Authorization", "X-Requested-With", "Accept", "Origin"];
+class CorsHandler {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    // Pre-created preflight response for wildcard CORS
+    this.preflightResponse = null;
+    this.methodsStr = (config.methods || DEFAULT_CORS_METHODS).join(", "), this.headersStr = (config.allowedHeaders || DEFAULT_CORS_HEADERS).join(", "), this.exposedStr = config.exposedHeaders?.join(", ") || null, this.maxAgeStr = config.maxAge?.toString() || null, this.hasCredentials = !!config.credentials, this.isWildcard = config.origins === "*", this.matcher = this.buildMatcher(config.origins), this.isWildcard && (this.preflightResponse = new Response(null, {
+      status: 204,
+      headers: this.buildHeaders("*")
+    }));
+  }
+  /**
+   * Handle preflight (OPTIONS) request.
+   */
+  preflight(origin) {
+    return this.isWildcard && this.preflightResponse ? this.preflightResponse.clone() : this.isAllowed(origin) ? new Response(null, {
+      status: 204,
+      headers: this.getHeaders(origin)
+    }) : new Response(null, { status: 403 });
+  }
+  /**
+   * Apply CORS headers to a response.
+   */
+  apply(response, origin) {
+    if (!this.isAllowed(origin))
+      return response;
+    const headers = this.getHeaders(origin);
+    for (const [key, value] of Object.entries(headers))
+      response.headers.set(key, value);
+    return response;
+  }
+  /**
+   * Check if origin is allowed.
+   */
+  isAllowed(origin) {
+    return this.matcher(origin);
+  }
+  /**
+   * Get cached CORS headers for origin.
+   */
+  getHeaders(origin) {
+    const key = this.isWildcard ? "*" : origin;
+    let headers = this.cache.get(key);
+    return headers || (headers = this.buildHeaders(origin), this.cache.set(key, headers)), headers;
+  }
+  buildHeaders(origin) {
+    const headers = {
+      "Access-Control-Allow-Origin": this.isWildcard ? "*" : origin,
+      "Access-Control-Allow-Methods": this.methodsStr,
+      "Access-Control-Allow-Headers": this.headersStr
+    };
+    return this.hasCredentials && (headers["Access-Control-Allow-Credentials"] = "true"), this.exposedStr && (headers["Access-Control-Expose-Headers"] = this.exposedStr), this.maxAgeStr && (headers["Access-Control-Max-Age"] = this.maxAgeStr), headers;
+  }
+  buildMatcher(origins) {
+    if (origins === "*") return () => !0;
+    if (typeof origins == "string") return (o) => o === origins;
+    if (Array.isArray(origins)) {
+      const set = new Set(origins);
+      return (o) => set.has(o);
+    }
+    return origins instanceof RegExp ? (o) => origins.test(o) : typeof origins == "function" ? origins : () => !1;
+  }
+}
+export {
+  CorsHandler,
+  DEFAULT_CORS_HEADERS,
+  DEFAULT_CORS_METHODS
+};

package/dist/decorators/Controller.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var Controller_exports = {};
+__export(Controller_exports, {
+  Controller: () => Controller
+});
+module.exports = __toCommonJS(Controller_exports);
+var import_metadata = require('../metadata.js');
+function normalizeOptions(pathOrOptions) {
+  return pathOrOptions ? typeof pathOrOptions == "string" ? { path: pathOrOptions } : pathOrOptions : {};
+}
+function normalizePath(path) {
+  if (!path) return "";
+  let normalized = path.startsWith("/") ? path : "/" + path;
+  return normalized !== "/" && normalized.endsWith("/") && (normalized = normalized.slice(0, -1)), normalized;
+}
+function Controller(pathOrOptions) {
+  return (target) => {
+    const options = normalizeOptions(pathOrOptions), meta = {
+      path: normalizePath(options.path || ""),
+      scope: options.scope,
+      children: options.children
+    };
+    Reflect.defineMetadata(import_metadata.CONTROLLER_META, meta, target), Reflect.hasMetadata(import_metadata.ROUTES_META, target) || Reflect.defineMetadata(import_metadata.ROUTES_META, [], target);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Controller
+});

package/dist/decorators/Controller.mjs

@@ -0,0 +1,22 @@
+import { CONTROLLER_META, ROUTES_META } from "../metadata.mjs";
+function normalizeOptions(pathOrOptions) {
+  return pathOrOptions ? typeof pathOrOptions == "string" ? { path: pathOrOptions } : pathOrOptions : {};
+}
+function normalizePath(path) {
+  if (!path) return "";
+  let normalized = path.startsWith("/") ? path : "/" + path;
+  return normalized !== "/" && normalized.endsWith("/") && (normalized = normalized.slice(0, -1)), normalized;
+}
+function Controller(pathOrOptions) {
+  return (target) => {
+    const options = normalizeOptions(pathOrOptions), meta = {
+      path: normalizePath(options.path || ""),
+      scope: options.scope,
+      children: options.children
+    };
+    Reflect.defineMetadata(CONTROLLER_META, meta, target), Reflect.hasMetadata(ROUTES_META, target) || Reflect.defineMetadata(ROUTES_META, [], target);
+  };
+}
+export {
+  Controller
+};

package/dist/decorators/Inject.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var Inject_exports = {};
+__export(Inject_exports, {
+  Inject: () => Inject
+});
+module.exports = __toCommonJS(Inject_exports);
+var import_metadata = require('../metadata.js');
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(import_metadata.INJECT_META, target) || /* @__PURE__ */ new Map();
+    existing.set(parameterIndex, token), Reflect.defineMetadata(import_metadata.INJECT_META, existing, target);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Inject
+});

package/dist/decorators/Inject.mjs

@@ -0,0 +1,10 @@
+import { INJECT_META } from "../metadata.mjs";
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(INJECT_META, target) || /* @__PURE__ */ new Map();
+    existing.set(parameterIndex, token), Reflect.defineMetadata(INJECT_META, existing, target);
+  };
+}
+export {
+  Inject
+};

package/dist/decorators/Middleware.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var Middleware_exports = {};
+__export(Middleware_exports, {
+  Use: () => Use
+});
+module.exports = __toCommonJS(Middleware_exports);
+var import_metadata = require('../metadata.js');
+function Use(...middlewares) {
+  return function(target, propertyKey) {
+    const isMethod = propertyKey !== void 0, metaTarget = isMethod ? target.constructor : target, existing = Reflect.getMetadata(import_metadata.MIDDLEWARE_META, metaTarget) || [];
+    for (const handler of middlewares)
+      existing.push({
+        handler,
+        target: isMethod ? propertyKey : void 0
+      });
+    Reflect.defineMetadata(import_metadata.MIDDLEWARE_META, existing, metaTarget);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Use
+});

package/dist/decorators/Middleware.mjs

@@ -0,0 +1,15 @@
+import { MIDDLEWARE_META } from "../metadata.mjs";
+function Use(...middlewares) {
+  return function(target, propertyKey) {
+    const isMethod = propertyKey !== void 0, metaTarget = isMethod ? target.constructor : target, existing = Reflect.getMetadata(MIDDLEWARE_META, metaTarget) || [];
+    for (const handler of middlewares)
+      existing.push({
+        handler,
+        target: isMethod ? propertyKey : void 0
+      });
+    Reflect.defineMetadata(MIDDLEWARE_META, existing, metaTarget);
+  };
+}
+export {
+  Use
+};