alien-middleware 0.8.2 → 0.9.0

package/dist/chunk-OH7VM54L.js

@@ -0,0 +1,175 @@
+// node_modules/.pnpm/radashi@12.5.0-beta.6d5c035/node_modules/radashi/dist/radashi.js
+function noop() {
+}
+var isArray = /* @__PURE__ */ (() => Array.isArray)();
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/url.ts
+var urlDescriptor = {
+  configurable: true,
+  get() {
+    const url = new URL(this.request.url);
+    Object.defineProperty(this, "url", { value: url });
+    return url;
+  }
+};
+function defineParsedURL(context) {
+  if (!("url" in context)) {
+    Object.defineProperty(context, "url", urlDescriptor);
+  }
+}
+
+// src/index.ts
+var kRequestChain = Symbol("requestChain");
+var kResponseChain = Symbol("responseChain");
+var kIgnoreNotFound = Symbol("ignoreNotFound");
+var kMiddlewareCache = Symbol("middlewareCache");
+var kResponseHeaders = Symbol("responseHeaders");
+var MiddlewareChain = class _MiddlewareChain {
+  [kRequestChain] = [];
+  [kResponseChain] = [];
+  /**
+   * Attach a middleware. If the `response` parameter is declared, it will be
+   * treated as a response middleware. Otherwise, it will be treated as a
+   * request middleware.
+   *
+   * If a middleware chain is given, its middlewares will be executed after any
+   * existing middlewares in this chain.
+   *
+   * @returns a new `MiddlewareChain` instance
+   */
+  use(middleware) {
+    if (middleware instanceof _MiddlewareChain) {
+      return createHandler(
+        [...this[kRequestChain], ...middleware[kRequestChain]],
+        [...this[kResponseChain], ...middleware[kResponseChain]]
+      );
+    }
+    let requestChain = this[kRequestChain];
+    let responseChain = this[kResponseChain];
+    if (middleware.length < 2) {
+      requestChain = [...requestChain, middleware];
+    } else {
+      responseChain = [...responseChain, middleware];
+    }
+    return createHandler(requestChain, responseChain);
+  }
+  /**
+   * Create a middleware function that encapsulates this middleware chain, so
+   * any modifications it makes to the request context are not leaked.
+   */
+  isolate() {
+    return isFunction(this) ? (ctx) => this(ctx) : noop;
+  }
+};
+function createHandler(requestChain, responseChain) {
+  async function handler(parentContext) {
+    const context = Object.create(parentContext);
+    context[kIgnoreNotFound] = true;
+    defineParsedURL(context);
+    const { passThrough } = context;
+    let shouldPassThrough = false;
+    context.passThrough = () => {
+      shouldPassThrough = true;
+    };
+    context.setHeader = (name, value) => {
+      if (context[kResponseHeaders] === parentContext[kResponseHeaders]) {
+        context[kResponseHeaders] = new Headers(parentContext[kResponseHeaders]);
+      }
+      context[kResponseHeaders].set(name, value);
+    };
+    const cache = context[kMiddlewareCache] ||= /* @__PURE__ */ new Set();
+    let response;
+    let env;
+    for (const middleware of requestChain) {
+      if (cache.has(middleware)) {
+        continue;
+      }
+      cache.add(middleware);
+      let result = middleware(context);
+      if (result instanceof Promise) {
+        result = await result;
+      }
+      if (shouldPassThrough) {
+        break;
+      }
+      if (result) {
+        if (result instanceof Response) {
+          response = result;
+          break;
+        }
+        for (const key in result) {
+          if (key === "env") {
+            env ||= createExtendedEnv(context);
+            Object.defineProperties(
+              env,
+              Object.getOwnPropertyDescriptors(result.env)
+            );
+          } else {
+            const descriptor = Object.getOwnPropertyDescriptor(result, key);
+            descriptor.configurable = false;
+            Object.defineProperty(context, key, descriptor);
+          }
+        }
+      }
+    }
+    if (!response) {
+      if (parentContext[kIgnoreNotFound]) {
+        return;
+      }
+      response = new Response("Not Found", { status: 404 });
+      if (shouldPassThrough) {
+        passThrough();
+        return response;
+      }
+    } else if (response.type !== "default") {
+      response = new Response(response.body, response);
+    }
+    context[kResponseHeaders]?.forEach((value, name) => {
+      response.headers.set(name, value);
+    });
+    context.setHeader = null;
+    for (const middleware of responseChain) {
+      if (cache.has(middleware)) {
+        continue;
+      }
+      cache.add(middleware);
+      let result = middleware(context, response);
+      if (result instanceof Promise) {
+        result = await result;
+      }
+      if (result && result instanceof Response) {
+        response = result;
+        continue;
+      }
+    }
+    return response;
+  }
+  Object.setPrototypeOf(handler, MiddlewareChain.prototype);
+  handler[kRequestChain] = requestChain;
+  handler[kResponseChain] = responseChain;
+  return handler;
+}
+function createExtendedEnv(context) {
+  const env = /* @__PURE__ */ Object.create(null);
+  const superEnv = context.env;
+  context.env = (key) => env[key] ?? superEnv(key);
+  return env;
+}
+function chain(middleware) {
+  if (middleware instanceof MiddlewareChain) {
+    return middleware;
+  }
+  const empty = new MiddlewareChain();
+  return middleware ? empty.use(middleware) : empty;
+}
+
+export {
+  isArray,
+  isFunction,
+  defineParsedURL,
+  MiddlewareChain,
+  chain
+};

package/dist/index-vRvlpUCy.d.ts

@@ -0,0 +1,212 @@
+import { Any, noop } from 'radashi';
+import { AdapterRequestContext, HattipHandler } from '@hattip/core';
+import { InferParams } from 'pathic';
+
+type Eval<T> = {} & {
+    [K in keyof T]: T[K] extends infer U ? U : never;
+};
+type Awaitable<T> = T | Promise<T>;
+type OneOrMany<T> = T | readonly T[];
+/**
+ * Converts a type `T` to something that can be intersected with an object.
+ */
+type Intersectable<T extends object> = [T] extends [never] ? {} : [T] extends [Any] ? Record<PropertyKey, any> : T;
+
+type Keys<T> = T extends any ? keyof T : never;
+type IsOptional<T, K> = K extends keyof T ? T[K] extends Required<T>[K] ? false : true : true;
+type PossiblyUndefined<T, K extends keyof T> = undefined extends Required<T>[K] ? true : false;
+type MergeProperty<TSource, TOverrides, K> = (K extends keyof TOverrides ? PossiblyUndefined<TOverrides, K> extends true ? TOverrides[K] : Exclude<TOverrides[K], undefined> : never) | (IsOptional<TOverrides, K> extends true ? K extends keyof TSource ? TSource[K] : undefined : never) extends infer TProperty ? TProperty : never;
+/**
+ * Merge a union of object types (possibly undefined) into a single object type.
+ *
+ * **FIXME:** Optional properties resolve as `foo: Foo | undefined` instead of `foo?: Foo`.
+ */
+type Merge<TSource extends object, TOverrides extends object | undefined> = Eval<Omit<TSource, Keys<TOverrides>> & {
+    [K in Keys<TOverrides>]: TOverrides extends any ? MergeProperty<TSource, TOverrides, K> : never;
+}>;
+
+type RequestEnvPlugin = {
+    /**
+     * Add type-safe environment variables. These are accessed with the `env()`
+     * method on the request context.
+     */
+    env?: object;
+};
+/**
+ * The object returned by a request middleware that is merged into the request
+ * context. The same context property cannot be defined by two different
+ * plugins, or an error will be thrown at runtime.
+ *
+ * May contain special properties:
+ * - `env`: Add type-safe environment variables.
+ */
+type RequestPlugin = Record<string, unknown> & RequestEnvPlugin;
+type MiddlewareTypes = {
+    /** Values expected by the start of the chain. */
+    initial: {
+        env: object;
+        properties: object;
+    };
+    /** Values provided by the end of the chain. */
+    current: {
+        env: object;
+        properties: object;
+    };
+    /** Values from the host platform. */
+    platform: unknown;
+};
+type AnyMiddlewareTypes = {
+    initial: {
+        env: any;
+        properties: any;
+    };
+    current: {
+        env: any;
+        properties: any;
+    };
+    platform: any;
+};
+type AnyMiddlewareChain = MiddlewareChain<AnyMiddlewareTypes>;
+type Inputs<T extends AnyMiddlewareChain> = T['$']['initial'];
+type InputProperties<T extends AnyMiddlewareChain> = Inputs<T>['properties'];
+type InputEnv<T extends AnyMiddlewareChain> = Inputs<T>['env'];
+type Current<T extends AnyMiddlewareChain> = T['$']['current'];
+type Properties<T extends AnyMiddlewareChain> = Current<T>['properties'];
+type Env<T extends AnyMiddlewareChain> = Current<T>['env'];
+type Platform<T extends AnyMiddlewareChain> = T['$']['platform'];
+interface HattipContext<TPlatform, TEnv extends object> extends AdapterRequestContext<TPlatform> {
+    /**
+     * The `request.url` string parsed into a `URL` object. Parsing is performed
+     * on-demand and the result is cached.
+     */
+    url: URL;
+    env<K extends keyof TEnv>(key: Extract<K, string>): TEnv[K];
+    env(key: never): string | undefined;
+    /**
+     * Set a response header from a request middleware.
+     *
+     * Response middlewares should use `response.headers.set()` instead.
+     */
+    setHeader(name: string, value: string): void;
+}
+/**
+ * An extensible Hattip context object.
+ *
+ * NOTE: When using this type on the right side of an `extends` clause, you
+ * should prefer `RequestContext<any>` over `RequestContext` (no type
+ * parameters), as the default type is stricter.
+ */
+type RequestContext<TEnv extends object = any, TProperties extends object = never, TPlatform = any> = HattipContext<TPlatform, TEnv> & Intersectable<TProperties>;
+/**
+ * Extract a `RequestContext` type from a `MiddlewareChain` type.
+ *
+ * When type `T` is `never`, a default context is returned.
+ */
+type MiddlewareContext<T extends MiddlewareChain> = [T] extends [never] ? RequestContext<{}, never, unknown> : RequestContext<Env<T>, Properties<T>, Platform<T>>;
+type IsolatedContext<T extends MiddlewareChain> = RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>;
+type RequestMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>) => Awaitable<Response | RequestPlugin | void>;
+type ResponseMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>, response: Response) => Awaitable<Response | void>;
+interface RequestHandler<T extends MiddlewareTypes = any> extends HattipHandler<T['platform']>, MiddlewareChain<T> {
+}
+/**
+ * Either a request middleware or a response middleware.
+ *
+ * If your middleware declares the `response` parameter, it's treated as a
+ * response middleware. This means it will run *after* a `Response` is generated
+ * by a request middleware.
+ */
+type Middleware<TEnv extends object = any, TProperties extends object = any, TPlatform = any> = (context: RequestContext<TEnv, TProperties, TPlatform>, response: Response) => Awaitable<Response | RequestPlugin | void>;
+/**
+ * Extract a `Middleware` type from a `MiddlewareChain` type.
+ */
+type ExtractMiddleware<T extends MiddlewareChain> = Middleware<Env<T>, Properties<T>, Platform<T>>;
+/**
+ * Merge a request plugin into a middleware chain.
+ */
+type ApplyMiddlewareResult<TParent extends MiddlewareChain, TResult> = Eval<{
+    env: Merge<Env<TParent>, TResult extends {
+        env: infer TEnv extends object | undefined;
+    } ? TEnv : undefined>;
+    properties: Merge<Properties<TParent>, TResult extends RequestPlugin ? Omit<TResult, keyof RequestEnvPlugin> : undefined>;
+}>;
+/**
+ * This applies a middleware to a chain. If the type `TMiddleware` is itself a
+ * chain, it's treated as a nested chain, which won't leak its plugins into the
+ * parent chain.
+ */
+type ApplyMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware<Env<TFirst>, Properties<TFirst>, Platform<TFirst>>> = (TSecond extends MiddlewareChain ? {
+    env: Merge<Env<TFirst>, Env<TSecond>>;
+    properties: Merge<Properties<TFirst>, Properties<TSecond>>;
+} : TSecond extends (...args: any[]) => Awaitable<infer TResult> ? ApplyMiddlewareResult<TFirst, TResult> : Current<TFirst>) extends infer TOutputs extends MiddlewareTypes['current'] ? RequestHandler<{
+    initial: Inputs<TFirst>;
+    current: TOutputs;
+    platform: Platform<TFirst>;
+}> : never;
+type EmptyMiddlewareChain = MiddlewareChain<{
+    initial: {
+        env: {};
+        properties: {};
+    };
+    current: {
+        env: {};
+        properties: {};
+    };
+    platform: unknown;
+}>;
+type ApplyFirstMiddleware<T extends Middleware> = T extends MiddlewareChain ? T : ApplyMiddleware<EmptyMiddlewareChain, T>;
+type RouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | (string & {});
+type RouteContext<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = MiddlewareContext<ApplyMiddleware<MiddlewareChain<T['$']>, () => {
+    params: TPathParams;
+    method: TMethod;
+}>>;
+type RouteHandler<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = (context: RouteContext<T, TPathParams, TMethod>) => Awaitable<Response | void>;
+declare class RouterTypes<T extends MiddlewareChain = any> extends Function {
+    /** This property won't exist at runtime. It contains type information for inference purposes. */
+    $: T['$'];
+}
+interface Router<T extends MiddlewareChain = any> extends RouterTypes<T> {
+    (context: AdapterRequestContext<Platform<T>>): Awaitable<void | Response>;
+    use<TPath extends string>(path: TPath, handler: RouteHandler<this, InferParams<TPath>>): Router;
+    use<TPath extends string, TMethod extends RouteMethod = RouteMethod>(method: OneOrMany<TMethod> | '*', path: TPath, handler: RouteHandler<this, InferParams<TPath>, TMethod>): Router;
+}
+
+declare const kRequestChain: unique symbol;
+declare const kResponseChain: unique symbol;
+declare class MiddlewareChain<T extends MiddlewareTypes = any> {
+    /** This property won't exist at runtime. It contains type information for inference purposes. */
+    $: T;
+    /** The number of parameters when called as a function. */
+    readonly length: 1;
+    protected [kRequestChain]: RequestMiddleware[];
+    protected [kResponseChain]: ResponseMiddleware[];
+    /**
+     * Attach a middleware. If the `response` parameter is declared, it will be
+     * treated as a response middleware. Otherwise, it will be treated as a
+     * request middleware.
+     *
+     * If a middleware chain is given, its middlewares will be executed after any
+     * existing middlewares in this chain.
+     *
+     * @returns a new `MiddlewareChain` instance
+     */
+    use<const TMiddleware extends ExtractMiddleware<this>>(middleware: TMiddleware): ApplyMiddleware<this, TMiddleware>;
+    /**
+     * Create a middleware function that encapsulates this middleware chain, so
+     * any modifications it makes to the request context are not leaked.
+     */
+    isolate(): ((ctx: IsolatedContext<this>) => Promise<Response | void>) | typeof noop;
+}
+declare function chain<TEnv extends object = {}, TProperties extends object = {}, TPlatform = unknown>(): MiddlewareChain<{
+    initial: {
+        env: TEnv;
+        properties: TProperties;
+    };
+    current: {
+        env: TEnv;
+        properties: TProperties;
+    };
+    platform: TPlatform;
+}>;
+declare function chain<const T extends Middleware = Middleware>(middleware: T): ApplyFirstMiddleware<T>;
+
+export { type ApplyMiddleware as A, type EmptyMiddlewareChain as E, type MiddlewareContext as M, type Router as R, MiddlewareChain as a, type RouteContext as b, type RouteHandler as c, chain as d, type ExtractMiddleware as e, type Middleware as f, type RequestContext as g, type RequestHandler as h, type RequestMiddleware as i, type RequestPlugin as j, type ResponseMiddleware as k };

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 import 'radashi';
-export { A as ApplyMiddleware, e as ExtractMiddleware, f as Middleware, M as MiddlewareChain, a as MiddlewareContext, g as RequestContext, h as RequestHandler, i as RequestMiddleware, j as RequestPlugin, k as ResponseMiddleware, d as chain } from './index-Bpx2B6hx.js';
+export { A as ApplyMiddleware, e as ExtractMiddleware, f as Middleware, a as MiddlewareChain, M as MiddlewareContext, g as RequestContext, h as RequestHandler, i as RequestMiddleware, j as RequestPlugin, k as ResponseMiddleware, d as chain } from './index-vRvlpUCy.js';
 import '@hattip/core';
+import 'pathic';

package/dist/index.js

@@ -1,142 +1,7 @@
 import {
-  defineParsedURL,
-  isFunction,
-  noop
-} from "./chunk-HZDENULC.js";
-
-// src/index.ts
-var kRequestChain = Symbol("requestChain");
-var kResponseChain = Symbol("responseChain");
-var kIgnoreNotFound = Symbol("ignoreNotFound");
-var kMiddlewareCache = Symbol("middlewareCache");
-var MiddlewareChain = class _MiddlewareChain {
-  [kRequestChain] = [];
-  [kResponseChain] = [];
-  /**
-   * Attach a middleware. If the `response` parameter is declared, it will be
-   * treated as a response middleware. Otherwise, it will be treated as a
-   * request middleware.
-   *
-   * If a middleware chain is given, its middlewares will be executed after any
-   * existing middlewares in this chain.
-   *
-   * @returns a new `MiddlewareChain` instance
-   */
-  use(middleware) {
-    if (middleware instanceof _MiddlewareChain) {
-      return createHandler(
-        [...this[kRequestChain], ...middleware[kRequestChain]],
-        [...this[kResponseChain], ...middleware[kResponseChain]]
-      );
-    }
-    let requestChain = this[kRequestChain];
-    let responseChain = this[kResponseChain];
-    if (middleware.length < 2) {
-      requestChain = [...requestChain, middleware];
-    } else {
-      responseChain = [...responseChain, middleware];
-    }
-    return createHandler(requestChain, responseChain);
-  }
-  /**
-   * Create a middleware function that encapsulates this middleware chain, so
-   * any modifications it makes to the request context are not leaked.
-   */
-  isolate() {
-    return isFunction(this) ? (ctx) => this(ctx) : noop;
-  }
-};
-function createHandler(requestChain, responseChain) {
-  async function handler(parentContext) {
-    const context = Object.create(parentContext);
-    context[kIgnoreNotFound] = true;
-    defineParsedURL(context);
-    const { passThrough } = context;
-    let shouldPassThrough = false;
-    context.passThrough = () => {
-      shouldPassThrough = true;
-    };
-    const cache = context[kMiddlewareCache] ||= /* @__PURE__ */ new Set();
-    let response;
-    let env;
-    for (const middleware of requestChain) {
-      if (cache.has(middleware)) {
-        continue;
-      }
-      cache.add(middleware);
-      let result = middleware(context);
-      if (result instanceof Promise) {
-        result = await result;
-      }
-      if (shouldPassThrough) {
-        break;
-      }
-      if (result) {
-        if (result instanceof Response) {
-          response = result;
-          break;
-        }
-        for (const key in result) {
-          if (key === "env") {
-            env ||= createExtendedEnv(context);
-            Object.defineProperties(
-              env,
-              Object.getOwnPropertyDescriptors(result.env)
-            );
-          } else {
-            const descriptor = Object.getOwnPropertyDescriptor(result, key);
-            descriptor.configurable = false;
-            Object.defineProperty(context, key, descriptor);
-          }
-        }
-      }
-    }
-    if (!response) {
-      if (parentContext[kIgnoreNotFound]) {
-        return;
-      }
-      response = new Response("Not Found", { status: 404 });
-      if (shouldPassThrough) {
-        passThrough();
-        return response;
-      }
-    } else if (response.type !== "default") {
-      response = new Response(response.body, response);
-    }
-    for (const middleware of responseChain) {
-      if (cache.has(middleware)) {
-        continue;
-      }
-      cache.add(middleware);
-      let result = middleware(context, response);
-      if (result instanceof Promise) {
-        result = await result;
-      }
-      if (result && result instanceof Response) {
-        response = result;
-        continue;
-      }
-    }
-    return response;
-  }
-  Object.setPrototypeOf(handler, MiddlewareChain.prototype);
-  handler[kRequestChain] = requestChain;
-  handler[kResponseChain] = responseChain;
-  return handler;
-}
-function createExtendedEnv(context) {
-  const env = /* @__PURE__ */ Object.create(null);
-  const superEnv = context.env;
-  context.env = (key) => env[key] ?? superEnv(key);
-  return env;
-}
-function chain(middleware) {
-  if (middleware instanceof MiddlewareChain) {
-    return middleware;
-  }
-  const empty = new MiddlewareChain();
-  return middleware ? empty.use(middleware) : empty;
-}
+  MiddlewareChain,
+  chain
+} from "./chunk-OH7VM54L.js";
 export {
   MiddlewareChain,
   chain

package/dist/router.d.ts

@@ -1,17 +1,10 @@
-import { InferParams } from 'pathic';
-import { M as MiddlewareChain, E as EmptyMiddlewareChain, a as MiddlewareContext, R as RouteHandler, b as RouteMethod } from './index-Bpx2B6hx.js';
-export { c as RouterContext } from './index-Bpx2B6hx.js';
+import { R as Router, M as MiddlewareContext, a as MiddlewareChain, E as EmptyMiddlewareChain } from './index-vRvlpUCy.js';
+export { b as RouteContext, c as RouteHandler } from './index-vRvlpUCy.js';
 import 'radashi';
 import '@hattip/core';
+import 'pathic';
 
-type OneOrMany<T> = T | readonly T[];
-type Router<T extends MiddlewareChain = any> = ReturnType<typeof routes<T>>;
-declare function routes<T extends MiddlewareChain = EmptyMiddlewareChain>(middlewares?: T): {
-    (context: MiddlewareContext<T>): void | Response | Promise<void | Response> | undefined;
-    use: {
-        <TPath extends string>(path: TPath, handler: RouteHandler<T, InferParams<TPath>>): /*elided*/ any;
-        <TPath extends string, TMethod extends RouteMethod = RouteMethod>(method: OneOrMany<TMethod> | "*", path: TPath, handler: RouteHandler<T, InferParams<TPath>, TMethod>): /*elided*/ any;
-    };
-};
+type RouterContext<TRouter extends Router> = TRouter extends Router<infer T> ? MiddlewareContext<T> : never;
+declare function routes<T extends MiddlewareChain = EmptyMiddlewareChain>(middlewares?: T): Router<T>;
 
-export { RouteHandler, type Router, routes };
+export { Router, type RouterContext, routes };

package/dist/router.js

@@ -1,8 +1,9 @@
 import {
+  chain,
   defineParsedURL,
   isArray,
   isFunction
-} from "./chunk-HZDENULC.js";
+} from "./chunk-OH7VM54L.js";
 
 // src/router.ts
 import { compilePaths } from "pathic";
@@ -11,7 +12,23 @@ function routes(middlewares) {
   const filters = [];
   const handlers = [];
   let matcher;
-  function use(method, path, handler) {
+  function handle(context) {
+    const method = context.request.method;
+    defineParsedURL(context);
+    matcher ||= compilePaths(paths);
+    return matcher(context.url.pathname, (index, params) => {
+      if (!filters[index] || filters[index](method)) {
+        context.method = method;
+        context.params = params;
+        return handlers[index](context);
+      }
+    });
+  }
+  const run = middlewares?.use(handle) ?? chain(handle);
+  function router(context) {
+    return run(context);
+  }
+  router.use = (method, path, handler) => {
     if (isFunction(path)) {
       paths.push(method);
       filters.push(null);
@@ -25,21 +42,7 @@ function routes(middlewares) {
     }
     matcher = void 0;
     return router;
-  }
-  function router(context) {
-    defineParsedURL(context);
-    const { request, url } = context;
-    const method = request.method;
-    matcher ||= compilePaths(paths);
-    return matcher(url.pathname, (index, params) => {
-      if (!filters[index] || filters[index](method)) {
-        context.method = method;
-        context.params = params;
-        return middlewares ? middlewares.use(handlers[index])(context) : handlers[index](context);
-      }
-    });
-  }
-  router.use = use;
+  };
   return router;
 }
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "alien-middleware",
   "type": "module",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",

package/dist/chunk-HZDENULC.js

@@ -1,29 +0,0 @@
-// node_modules/.pnpm/radashi@12.5.0-beta.6d5c035/node_modules/radashi/dist/radashi.js
-function noop() {
-}
-var isArray = /* @__PURE__ */ (() => Array.isArray)();
-function isFunction(value) {
-  return typeof value === "function";
-}
-
-// src/url.ts
-var urlDescriptor = {
-  configurable: true,
-  get() {
-    const url = new URL(this.request.url);
-    Object.defineProperty(this, "url", { value: url });
-    return url;
-  }
-};
-function defineParsedURL(context) {
-  if (!("url" in context)) {
-    Object.defineProperty(context, "url", urlDescriptor);
-  }
-}
-
-export {
-  noop,
-  isArray,
-  isFunction,
-  defineParsedURL
-};

package/dist/index-Bpx2B6hx.d.ts

@@ -1,133 +0,0 @@
-import { Any, noop } from 'radashi';
-import { AdapterRequestContext, HattipHandler } from '@hattip/core';
-
-type RequestEnvPlugin = {
-    /**
-     * Add type-safe environment variables. These are accessed with the `env()`
-     * method on the request context.
-     */
-    env?: object;
-};
-/**
- * The object returned by a request middleware that is merged into the request
- * context. The same context property cannot be defined by two different
- * plugins, or an error will be thrown at runtime.
- *
- * May contain special properties:
- * - `env`: Add type-safe environment variables.
- */
-type RequestPlugin = Record<string, unknown> & RequestEnvPlugin;
-type Inputs<T extends MiddlewareChain> = T['$']['input'];
-type Platform<T extends MiddlewareChain> = T['$']['platform'];
-type InputProperties<T extends MiddlewareChain> = Inputs<T>['properties'];
-type InputEnv<T extends MiddlewareChain> = Inputs<T>['env'];
-type Current<T extends MiddlewareChain> = T['$']['current'];
-type Properties<T extends MiddlewareChain> = Current<T>['properties'];
-type Env<T extends MiddlewareChain> = Current<T>['env'];
-type MiddlewareTypes<TEnv extends object = any, TProperties extends object = any> = {
-    env: TEnv;
-    properties: TProperties;
-};
-interface HattipContext<TPlatform, TEnv extends object> extends AdapterRequestContext<TPlatform> {
-    /**
-     * The `request.url` string parsed into a `URL` object. Parsing is performed
-     * on-demand and the result is cached.
-     */
-    url: URL;
-    env<K extends keyof TEnv>(key: Extract<K, string>): TEnv[K];
-    env(key: never): string | undefined;
-}
-/**
- * Converts a type `T` to something that can be intersected with an object.
- */
-type Intersectable<T extends object> = [T] extends [never] ? {} : [T] extends [Any] ? Record<PropertyKey, any> : T;
-/**
- * An extensible Hattip context object.
- *
- * NOTE: When using this type on the right side of an `extends` clause, you
- * should prefer `RequestContext<any>` over `RequestContext` (no type
- * parameters), as the default type is stricter.
- */
-type RequestContext<TEnv extends object = any, TProperties extends object = never, TPlatform = any> = HattipContext<TPlatform, TEnv> & Intersectable<TProperties>;
-/**
- * Extract a `RequestContext` type from a `MiddlewareChain` type.
- *
- * When type `T` is `never`, a default context is returned.
- */
-type MiddlewareContext<T extends MiddlewareChain> = [T] extends [never] ? RequestContext<{}, never, unknown> : RequestContext<Env<T>, Properties<T>, Platform<T>>;
-type IsolatedContext<T extends MiddlewareChain> = RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>;
-type Awaitable<T> = T | Promise<T>;
-type RequestMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>) => Awaitable<Response | RequestPlugin | void>;
-type ResponseMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>, response: Response) => Awaitable<Response | void>;
-type RequestHandler<TInputs extends MiddlewareTypes = any, TCurrent extends MiddlewareTypes = any, TPlatform = any> = HattipHandler<TPlatform> & MiddlewareChain<TInputs, TCurrent, TPlatform>;
-/**
- * Either a request middleware or a response middleware.
- *
- * If your middleware declares the `response` parameter, it's treated as a
- * response middleware. This means it will run *after* a `Response` is generated
- * by a request middleware.
- */
-type Middleware<TEnv extends object = any, TProperties extends object = any, TPlatform = any> = (context: RequestContext<TEnv, TProperties, TPlatform>, response: Response) => Awaitable<Response | RequestPlugin | void>;
-/**
- * Extract a `Middleware` type from a `MiddlewareChain` type.
- */
-type ExtractMiddleware<T extends MiddlewareChain> = Middleware<Env<T>, Properties<T>, Platform<T>>;
-type Merge<TSource extends object, TOverrides extends object | undefined> = {} & (TOverrides extends object ? {
-    [K in keyof TSource | keyof TOverrides]: K extends keyof TOverrides ? TOverrides[K] : K extends keyof TSource ? TSource[K] : never;
-} : TSource);
-type ApplyRequestPlugin<TParent extends MiddlewareChain, TPlugin extends RequestPlugin> = {} & MiddlewareTypes<Merge<Env<TParent>, TPlugin['env']>, Merge<Properties<TParent>, Omit<TPlugin, keyof RequestEnvPlugin>>>;
-/**
- * This applies a middleware to a chain. If the type `TMiddleware` is itself a
- * chain, it's treated as a nested chain, which won't leak its plugins into the
- * parent chain.
- */
-type ApplyMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware<Env<TFirst>, Properties<TFirst>, Platform<TFirst>>> = RequestHandler<Inputs<TFirst>, TSecond extends MiddlewareChain ? MiddlewareTypes<Merge<Env<TFirst>, Env<TSecond>>, Merge<Properties<TFirst>, Properties<TSecond>>> : TSecond extends (...args: any[]) => Awaitable<infer TResult> ? TResult extends RequestPlugin ? ApplyRequestPlugin<TFirst, TResult> : Current<TFirst> : Current<TFirst>, Platform<TFirst>>;
-type EmptyMiddlewareChain = MiddlewareChain<MiddlewareTypes<{}, {}>, MiddlewareTypes<{}, {}>, unknown>;
-type ApplyFirstMiddleware<T extends Middleware> = T extends MiddlewareChain ? T : ApplyMiddleware<EmptyMiddlewareChain, T>;
-type RouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
-type RouterContext<T extends MiddlewareChain = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = MiddlewareContext<T> & {
-    params: TPathParams;
-    method: TMethod;
-};
-type RouteHandler<T extends MiddlewareChain = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = (context: RouterContext<T, TPathParams, TMethod>) => Awaitable<Response | void>;
-
-declare const kRequestChain: unique symbol;
-declare const kResponseChain: unique symbol;
-declare class MiddlewareChain<
-/** Values expected by the start of the chain. */
-TInputs extends MiddlewareTypes = any, 
-/** Values provided by the end of the chain. */
-TCurrent extends MiddlewareTypes = any, 
-/** Values from the host platform. */
-TPlatform = any> {
-    /** This property won't exist at runtime. It contains type information for inference purposes. */
-    $: {
-        input: TInputs;
-        current: TCurrent;
-        platform: TPlatform;
-    };
-    /** The number of parameters when called as a function. */
-    readonly length: 1;
-    protected [kRequestChain]: RequestMiddleware[];
-    protected [kResponseChain]: ResponseMiddleware[];
-    /**
-     * Attach a middleware. If the `response` parameter is declared, it will be
-     * treated as a response middleware. Otherwise, it will be treated as a
-     * request middleware.
-     *
-     * If a middleware chain is given, its middlewares will be executed after any
-     * existing middlewares in this chain.
-     *
-     * @returns a new `MiddlewareChain` instance
-     */
-    use<const TMiddleware extends ExtractMiddleware<this>>(middleware: TMiddleware): ApplyMiddleware<this, TMiddleware>;
-    /**
-     * Create a middleware function that encapsulates this middleware chain, so
-     * any modifications it makes to the request context are not leaked.
-     */
-    isolate(): ((ctx: IsolatedContext<this>) => Promise<Response | void>) | typeof noop;
-}
-declare function chain<TEnv extends object = {}, TProperties extends object = {}, TPlatform = unknown>(): MiddlewareChain<MiddlewareTypes<TEnv, TProperties>, MiddlewareTypes<TEnv, TProperties>, TPlatform>;
-declare function chain<const T extends Middleware = Middleware>(middleware: T): ApplyFirstMiddleware<T>;
-
-export { type ApplyMiddleware as A, type EmptyMiddlewareChain as E, MiddlewareChain as M, type RouteHandler as R, type MiddlewareContext as a, type RouteMethod as b, type RouterContext as c, chain as d, type ExtractMiddleware as e, type Middleware as f, type RequestContext as g, type RequestHandler as h, type RequestMiddleware as i, type RequestPlugin as j, type ResponseMiddleware as k };