hono 4.6.19 → 4.7.0

package/dist/helper/streaming/sse.js

@@ -1,6 +1,7 @@
 // src/helper/streaming/sse.ts
 import { HtmlEscapedCallbackPhase, resolveCallback } from "../../utils/html.js";
 import { StreamingApi } from "../../utils/stream.js";
+import { isOldBunVersion } from "./utils.js";
 var SSEStreamingApi = class extends StreamingApi {
   constructor(writable, readable) {
     super(writable, readable);
@@ -40,11 +41,13 @@ var contextStash = /* @__PURE__ */ new WeakMap();
 var streamSSE = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream = new SSEStreamingApi(writable, readable);
-  c.req.raw.signal.addEventListener("abort", () => {
-    if (!stream.closed) {
-      stream.abort();
-    }
-  });
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream.closed) {
+        stream.abort();
+      }
+    });
+  }
   contextStash.set(stream.responseReadable, c);
   c.header("Transfer-Encoding", "chunked");
   c.header("Content-Type", "text/event-stream");

package/dist/helper/streaming/stream.js

@@ -1,14 +1,17 @@
 // src/helper/streaming/stream.ts
 import { StreamingApi } from "../../utils/stream.js";
+import { isOldBunVersion } from "./utils.js";
 var contextStash = /* @__PURE__ */ new WeakMap();
 var stream = (c, cb, onError) => {
   const { readable, writable } = new TransformStream();
   const stream2 = new StreamingApi(writable, readable);
-  c.req.raw.signal.addEventListener("abort", () => {
-    if (!stream2.closed) {
-      stream2.abort();
-    }
-  });
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
   contextStash.set(stream2.responseReadable, c);
   (async () => {
     try {

package/dist/helper/streaming/utils.js

@@ -0,0 +1,13 @@
+// src/helper/streaming/utils.ts
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+export {
+  isOldBunVersion
+};

package/dist/middleware/etag/digest.js

@@ -8,7 +8,7 @@ var mergeBuffers = (buffer1, buffer2) => {
   merged.set(buffer2, buffer1.byteLength);
   return merged;
 };
-var generateDigest = async (stream) => {
+var generateDigest = async (stream, generator) => {
   if (!stream || !crypto || !crypto.subtle) {
     return null;
   }
@@ -19,12 +19,7 @@ var generateDigest = async (stream) => {
     if (done) {
       break;
     }
-    result = await crypto.subtle.digest(
-      {
-        name: "SHA-1"
-      },
-      mergeBuffers(result, value)
-    );
+    result = await generator(mergeBuffers(result, value));
   }
   if (!result) {
     return null;

package/dist/middleware/etag/index.js

@@ -14,20 +14,25 @@ function etagMatches(etag2, ifNoneMatch) {
 var etag = (options) => {
   const retainedHeaders = options?.retainedHeaders ?? RETAINED_304_HEADERS;
   const weak = options?.weak ?? false;
+  const generator = options?.generateDigest ?? ((body) => crypto.subtle.digest(
+    {
+      name: "SHA-1"
+    },
+    body
+  ));
   return async function etag2(c, next) {
     const ifNoneMatch = c.req.header("If-None-Match") ?? null;
     await next();
     const res = c.res;
     let etag3 = res.headers.get("ETag");
     if (!etag3) {
-      const hash = await generateDigest(res.clone().body);
+      const hash = await generateDigest(res.clone().body, generator);
       if (hash === null) {
         return;
       }
       etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
     }
     if (etagMatches(etag3, ifNoneMatch)) {
-      await c.res.blob();
       c.res = new Response(null, {
         status: 304,
         statusText: "Not Modified",

package/dist/middleware/jwk/index.js

@@ -0,0 +1,5 @@
+// src/middleware/jwk/index.ts
+import { jwk } from "./jwk.js";
+export {
+  jwk
+};

package/dist/middleware/jwk/jwk.js

@@ -0,0 +1,101 @@
+// src/middleware/jwk/jwk.ts
+import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
+import { HTTPException } from "../../http-exception.js";
+import { Jwt } from "../../utils/jwt/index.js";
+import "../../context.js";
+var jwk = (options, init) => {
+  if (!options || !(options.keys || options.jwks_uri)) {
+    throw new Error('JWK auth middleware requires options for either "keys" or "jwks_uri" or both');
+  }
+  if (!crypto.subtle || !crypto.subtle.importKey) {
+    throw new Error("`crypto.subtle.importKey` is undefined. JWK auth middleware requires it.");
+  }
+  return async function jwk2(ctx, next) {
+    const credentials = ctx.req.raw.headers.get("Authorization");
+    let token;
+    if (credentials) {
+      const parts = credentials.split(/\s+/);
+      if (parts.length !== 2) {
+        const errDescription = "invalid credentials structure";
+        throw new HTTPException(401, {
+          message: errDescription,
+          res: unauthorizedResponse({
+            ctx,
+            error: "invalid_request",
+            errDescription
+          })
+        });
+      } else {
+        token = parts[1];
+      }
+    } else if (options.cookie) {
+      if (typeof options.cookie == "string") {
+        token = getCookie(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await getSignedCookie(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = getCookie(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = getCookie(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      const errDescription = "no authorization included in request";
+      throw new HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      payload = await Jwt.verifyFromJwks(token, options, init);
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      if (cause instanceof Error && cause.constructor === Error) {
+        throw cause;
+      }
+      throw new HTTPException(401, {
+        message: "Unauthorized",
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_token",
+          statusText: "Unauthorized",
+          errDescription: "token verification failure"
+        }),
+        cause
+      });
+    }
+    ctx.set("jwtPayload", payload);
+    await next();
+  };
+};
+function unauthorizedResponse(opts) {
+  return new Response("Unauthorized", {
+    status: 401,
+    statusText: opts.statusText,
+    headers: {
+      "WWW-Authenticate": `Bearer realm="${opts.ctx.req.url}",error="${opts.error}",error_description="${opts.errDescription}"`
+    }
+  });
+}
+export {
+  jwk
+};

package/dist/middleware/language/index.js

@@ -0,0 +1,15 @@
+// src/middleware/language/index.ts
+import {
+  languageDetector,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery
+} from "./language.js";
+export {
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  languageDetector
+};

package/dist/middleware/language/language.js

@@ -0,0 +1,178 @@
+// src/middleware/language/language.ts
+import { setCookie, getCookie } from "../../helper/cookie/index.js";
+import { parseAccept } from "../../utils/accept.js";
+var DEFAULT_OPTIONS = {
+  order: ["querystring", "cookie", "header"],
+  lookupQueryString: "lang",
+  lookupCookie: "language",
+  lookupFromHeaderKey: "accept-language",
+  lookupFromPathIndex: 0,
+  caches: ["cookie"],
+  ignoreCase: true,
+  fallbackLanguage: "en",
+  supportedLanguages: ["en"],
+  cookieOptions: {
+    sameSite: "Strict",
+    secure: true,
+    maxAge: 365 * 24 * 60 * 60,
+    httpOnly: true
+  },
+  debug: false
+};
+function parseAcceptLanguage(header) {
+  return parseAccept(header).map(({ type, q }) => ({ lang: type, q }));
+}
+var normalizeLanguage = (lang, options) => {
+  if (!lang) {
+    return void 0;
+  }
+  try {
+    let normalizedLang = lang.trim();
+    if (options.convertDetectedLanguage) {
+      normalizedLang = options.convertDetectedLanguage(normalizedLang);
+    }
+    const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
+    const compSupported = options.supportedLanguages.map(
+      (l) => options.ignoreCase ? l.toLowerCase() : l
+    );
+    const matchedLang = compSupported.find((l) => l === compLang);
+    return matchedLang ? options.supportedLanguages[compSupported.indexOf(matchedLang)] : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var detectFromQuery = (c, options) => {
+  try {
+    const query = c.req.query(options.lookupQueryString);
+    return normalizeLanguage(query, options);
+  } catch {
+    return void 0;
+  }
+};
+var detectFromCookie = (c, options) => {
+  try {
+    const cookie = getCookie(c, options.lookupCookie);
+    return normalizeLanguage(cookie, options);
+  } catch {
+    return void 0;
+  }
+};
+function detectFromHeader(c, options) {
+  try {
+    const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
+    if (!acceptLanguage) {
+      return void 0;
+    }
+    const languages = parseAcceptLanguage(acceptLanguage);
+    for (const { lang } of languages) {
+      const normalizedLang = normalizeLanguage(lang, options);
+      if (normalizedLang) {
+        return normalizedLang;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectFromPath(c, options) {
+  try {
+    const pathSegments = c.req.path.split("/").filter(Boolean);
+    const langSegment = pathSegments[options.lookupFromPathIndex];
+    return normalizeLanguage(langSegment, options);
+  } catch {
+    return void 0;
+  }
+}
+var detectors = {
+  querystring: detectFromQuery,
+  cookie: detectFromCookie,
+  header: detectFromHeader,
+  path: detectFromPath
+};
+function validateOptions(options) {
+  if (!options.supportedLanguages.includes(options.fallbackLanguage)) {
+    throw new Error("Fallback language must be included in supported languages");
+  }
+  if (options.lookupFromPathIndex < 0) {
+    throw new Error("Path index must be non-negative");
+  }
+  if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) {
+    throw new Error("Invalid detector type in order array");
+  }
+}
+function cacheLanguage(c, language, options) {
+  if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
+    return;
+  }
+  try {
+    setCookie(c, options.lookupCookie, language, options.cookieOptions);
+  } catch (error) {
+    if (options.debug) {
+      console.error("Failed to cache language:", error);
+    }
+  }
+}
+var detectLanguage = (c, options) => {
+  let detectedLang;
+  for (const detectorName of options.order) {
+    const detector = detectors[detectorName];
+    if (!detector) {
+      continue;
+    }
+    try {
+      detectedLang = detector(c, options);
+      if (detectedLang) {
+        if (options.debug) {
+          console.log(`Language detected from ${detectorName}: ${detectedLang}`);
+        }
+        break;
+      }
+    } catch (error) {
+      if (options.debug) {
+        console.error(`Error in ${detectorName} detector:`, error);
+      }
+      continue;
+    }
+  }
+  const finalLang = detectedLang || options.fallbackLanguage;
+  if (detectedLang && options.caches) {
+    cacheLanguage(c, finalLang, options);
+  }
+  return finalLang;
+};
+var languageDetector = (userOptions) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...userOptions,
+    cookieOptions: {
+      ...DEFAULT_OPTIONS.cookieOptions,
+      ...userOptions.cookieOptions
+    }
+  };
+  validateOptions(options);
+  return async function languageDetector2(ctx, next) {
+    try {
+      const lang = detectLanguage(ctx, options);
+      ctx.set("language", lang);
+    } catch (error) {
+      if (options.debug) {
+        console.error("Language detection failed:", error);
+      }
+      ctx.set("language", options.fallbackLanguage);
+    }
+    await next();
+  };
+};
+export {
+  DEFAULT_OPTIONS,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  detectors,
+  languageDetector,
+  normalizeLanguage,
+  parseAcceptLanguage,
+  validateOptions
+};

package/dist/middleware/logger/index.js

@@ -1,6 +1,5 @@
 // src/middleware/logger/index.ts
 import { getColorEnabled } from "../../utils/color.js";
-import { getPath } from "../../utils/url.js";
 var humanize = (times) => {
   const [delimiter, separator] = [",", "."];
   const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter));
@@ -32,8 +31,8 @@ function log(fn, prefix, method, path, status = 0, elapsed) {
 }
 var logger = (fn = console.log) => {
   return async function logger2(c, next) {
-    const { method } = c.req;
-    const path = getPath(c.req.raw);
+    const { method, url } = c.req;
+    const path = url.slice(url.indexOf("/", 8));
     log(fn, "<--" /* Incoming */, method, path);
     const start = Date.now();
     await next();

package/dist/request.js

@@ -45,7 +45,7 @@ var HonoRequest = class {
   }
   header(name) {
     if (name) {
-      return this.raw.headers.get(name.toLowerCase()) ?? void 0;
+      return this.raw.headers.get(name) ?? void 0;
     }
     const headerData = {};
     this.raw.headers.forEach((value, key) => {

package/dist/router/linear-router/router.js

@@ -66,7 +66,9 @@ var LinearRouter = class {
                 let value;
                 if (name.charCodeAt(name.length - 1) === 125) {
                   const openBracePos = name.indexOf("{");
-                  const pattern = name.slice(openBracePos + 1, -1);
+                  const next = parts[j + 1];
+                  const lookahead = next && next[1] !== ":" && next[1] !== "*" ? `(?=${next})` : "";
+                  const pattern = name.slice(openBracePos + 1, -1) + lookahead;
                   const restPath = path.slice(pos + 1);
                   const match = new RegExp(pattern, "d").exec(restPath);
                   if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {

package/dist/router/trie-router/node.js

@@ -25,21 +25,23 @@ var Node = class {
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
-      if (Object.keys(curNode.#children).includes(p)) {
-        curNode = curNode.#children[p];
-        const pattern2 = getPattern(p);
+      const nextP = parts[i + 1];
+      const pattern = getPattern(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (Object.keys(curNode.#children).includes(key)) {
+        curNode = curNode.#children[key];
+        const pattern2 = getPattern(p, nextP);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.#children[p] = new Node();
-      const pattern = getPattern(p);
+      curNode.#children[key] = new Node();
       if (pattern) {
         curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
       }
-      curNode = curNode.#children[p];
+      curNode = curNode.#children[key];
     }
     const m = /* @__PURE__ */ Object.create(null);
     const handlerSet = {
@@ -78,6 +80,7 @@ var Node = class {
     const curNode = this;
     let curNodes = [curNode];
     const parts = splitPath(path);
+    const curNodesQueue = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const part = parts[i];
       const isLast = i === len - 1;
@@ -105,6 +108,7 @@ var Node = class {
             const astNode = node.#children["*"];
             if (astNode) {
               handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
+              astNode.#params = params;
               tempNodes.push(astNode);
             }
             continue;
@@ -115,10 +119,19 @@ var Node = class {
           const [key, name, matcher] = pattern;
           const child = node.#children[key];
           const restPathString = parts.slice(i).join("/");
-          if (matcher instanceof RegExp && matcher.test(restPathString)) {
-            params[name] = restPathString;
-            handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
-            continue;
+          if (matcher instanceof RegExp) {
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
+              if (Object.keys(child.#children).length) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
           }
           if (matcher === true || matcher.test(part)) {
             params[name] = part;
@@ -136,7 +149,7 @@ var Node = class {
           }
         }
       }
-      curNodes = tempNodes;
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
     }
     if (handlerSets.length > 1) {
       handlerSets.sort((a, b) => {

package/dist/types/client/types.d.ts

@@ -47,7 +47,6 @@ export type ClientRequest<S extends Schema> = {
 } ? {
     $ws: (args?: I) => WebSocket;
 } : {} : {});
-type BlankRecordToNever<T> = T extends any ? T extends null ? null : keyof T extends never ? never : T : never;
 type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
     output: infer O;
     outputFormat: infer F;
@@ -63,7 +62,7 @@ export interface ClientResponse<T, U extends number = StatusCode, F extends Resp
     url: string;
     redirect(url: string, status: number): Response;
     clone(): Response;
-    json(): F extends "text" ? Promise<never> : F extends "json" ? Promise<BlankRecordToNever<T>> : Promise<unknown>;
+    json(): F extends "text" ? Promise<never> : F extends "json" ? Promise<T> : Promise<unknown>;
     text(): F extends "text" ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
     blob(): Promise<Blob>;
     formData(): Promise<FormData>;

package/dist/types/context.d.ts

@@ -7,9 +7,9 @@ import type { BaseMime } from './utils/mime';
 import type { InvalidJSONValue, IsAny, JSONParsed, JSONValue, SimplifyDeepArray } from './utils/types';
 type HeaderRecord = Record<"Content-Type", BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
 /**
- * Data type can be a string, ArrayBuffer, or ReadableStream.
+ * Data type can be a string, ArrayBuffer, Uint8Array (buffer), or ReadableStream.
  */
-export type Data = string | ArrayBuffer | ReadableStream;
+export type Data = string | ArrayBuffer | ReadableStream | Uint8Array;
 /**
  * Interface for the execution context in a web worker or similar environment.
  */

package/dist/types/helper/accepts/accepts.d.ts

@@ -13,7 +13,6 @@ export interface acceptsConfig {
 export interface acceptsOptions extends acceptsConfig {
     match?: (accepts: Accept[], config: acceptsConfig) => string;
 }
-export declare const parseAccept: (acceptHeader: string) => Accept[];
 export declare const defaultMatch: (accepts: Accept[], config: acceptsConfig) => string;
 /**
  * Match the accept header with the given options.

package/dist/types/helper/adapter/index.d.ts

@@ -6,7 +6,7 @@ import type { Context } from '../../context';
 export type Runtime = "node" | "deno" | "bun" | "workerd" | "fastly" | "edge-light" | "other";
 export declare const env: <T extends Record<string, unknown>, C extends Context = Context<{
     Bindings: T;
-}, any, {}>>(c: C, runtime?: Runtime) => T & C["env"];
+}, any, {}>>(c: T extends Record<string, unknown> ? Context : C, runtime?: Runtime) => T & C["env"];
 export declare const knownUserAgents: Partial<Record<Runtime, string>>;
 export declare const getRuntimeKey: () => Runtime;
 export declare const checkUserAgentEquals: (platform: string) => boolean;

package/dist/types/helper/factory/index.d.ts

@@ -3,6 +3,7 @@
  * Factory Helper for Hono.
  */
 import { Hono } from '../../hono';
+import type { HonoOptions } from '../../hono-base';
 import type { Env, H, HandlerResponse, Input, IntersectNonAnyTypes, MiddlewareHandler } from '../../types';
 type InitApp<E extends Env = Env> = (app: Hono<E>) => void;
 export interface CreateHandlersInterface<E extends Env, P extends string> {
@@ -340,13 +341,15 @@ export interface CreateHandlersInterface<E extends Env, P extends string> {
 export declare class Factory<E extends Env = Env, P extends string = string> {
     constructor(init?: {
         initApp?: InitApp<E>;
+        defaultAppOptions?: HonoOptions<E>;
     });
-    createApp: () => Hono<E>;
+    createApp: (options?: HonoOptions<E>) => Hono<E>;
     createMiddleware: <I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
     createHandlers: CreateHandlersInterface<E, P>;
 }
 export declare const createFactory: <E extends Env = Env, P extends string = string>(init?: {
     initApp?: InitApp<E>;
+    defaultAppOptions?: HonoOptions<E>;
 }) => Factory<E, P>;
 export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
 export {};

package/dist/types/helper/proxy/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module
+ * Proxy Helper for Hono.
+ */
+import type { RequestHeader } from '../../utils/headers';
+interface ProxyRequestInit extends Omit<RequestInit, "headers"> {
+    raw?: Request;
+    headers?: HeadersInit | [
+        string,
+        string
+    ][] | Record<RequestHeader, string | undefined> | Record<string, string | undefined>;
+}
+interface ProxyFetch {
+    (input: string | URL | Request, init?: ProxyRequestInit): Promise<Response>;
+}
+/**
+ * Fetch API wrapper for proxy.
+ * The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
+ *
+ * The “Accept-Encoding” header is replaced with an encoding that the current runtime can handle.
+ * Unnecessary response headers are deleted and a Response object is returned that can be returned
+ * as is as a response from the handler.
+ *
+ * @example
+ * ```ts
+ * app.get('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     headers: {
+ *       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   }).then((res) => {
+ *     res.headers.delete('Set-Cookie')
+ *     return res
+ *   })
+ * })
+ *
+ * app.all('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *     headers: {
+ *       ...c.req.header(),
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   })
+ * })
+ * ```
+ */
+export declare const proxy: ProxyFetch;
+export {};

package/dist/types/helper/streaming/utils.d.ts

@@ -0,0 +1 @@
+export declare let isOldBunVersion: () => boolean;