npm - @kerebron/extension-server-hono - Versions diffs - 0.4.4 → 0.4.6 - Mend

@kerebron/extension-server-hono 0.4.4 → 0.4.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/request.d.ts ADDED Viewed

@@ -0,0 +1,314 @@
+import { GET_MATCH_RESULT } from './request/constants.js';
+import type { Result } from './router.js';
+import type { Input, InputToDataByTarget, ParamKeyToRecord, ParamKeys, RemoveQuestion, RouterRoute, ValidationTargets } from './types.js';
+import type { BodyData, ParseBodyOptions } from './utils/body.js';
+import type { CustomHeader, RequestHeader } from './utils/headers.js';
+import type { Simplify, UnionToIntersection } from './utils/types.js';
+type Body = {
+    json: any;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    blob: Blob;
+    formData: FormData;
+};
+type BodyCache = Partial<Body & {
+    parsedBody: BodyData;
+}>;
+export declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
+    #private;
+    [GET_MATCH_RESULT]: Result<[unknown, RouterRoute]>;
+    /**
+     * `.raw` can get the raw Request object.
+     *
+     * @see {@link https://hono.dev/docs/api/request#raw}
+     *
+     * @example
+     * ```ts
+     * // For Cloudflare Workers
+     * app.post('/', async (c) => {
+     *   const metadata = c.req.raw.cf?.hostMetadata?
+     *   ...
+     * })
+     * ```
+     */
+    raw: Request;
+    routeIndex: number;
+    /**
+     * `.path` can get the pathname of the request.
+     *
+     * @see {@link https://hono.dev/docs/api/request#path}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const pathname = c.req.path // `/about/me`
+     * })
+     * ```
+     */
+    path: string;
+    bodyCache: BodyCache;
+    constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
+    /**
+     * `.req.param()` gets the path parameters.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#path-parameter}
+     *
+     * @example
+     * ```ts
+     * const name = c.req.param('name')
+     * // or all parameters at once
+     * const { id, comment_id } = c.req.param()
+     * ```
+     */
+    param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: P2 extends `${infer _}?` ? never : P2): string;
+    param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
+    param(key: string): string | undefined;
+    param<P2 extends string = P>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
+    /**
+     * `.query()` can get querystring parameters.
+     *
+     * @see {@link https://hono.dev/docs/api/request#query}
+     *
+     * @example
+     * ```ts
+     * // Query params
+     * app.get('/search', (c) => {
+     *   const query = c.req.query('q')
+     * })
+     *
+     * // Get all params at once
+     * app.get('/search', (c) => {
+     *   const { q, limit, offset } = c.req.query()
+     * })
+     * ```
+     */
+    query(key: string): string | undefined;
+    query(): Record<string, string>;
+    /**
+     * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
+     *
+     * @see {@link https://hono.dev/docs/api/request#queries}
+     *
+     * @example
+     * ```ts
+     * app.get('/search', (c) => {
+     *   // tags will be string[]
+     *   const tags = c.req.queries('tags')
+     * })
+     * ```
+     */
+    queries(key: string): string[] | undefined;
+    queries(): Record<string, string[]>;
+    /**
+     * `.header()` can get the request header value.
+     *
+     * @see {@link https://hono.dev/docs/api/request#header}
+     *
+     * @example
+     * ```ts
+     * app.get('/', (c) => {
+     *   const userAgent = c.req.header('User-Agent')
+     * })
+     * ```
+     */
+    header(name: RequestHeader): string | undefined;
+    header(name: string): string | undefined;
+    header(): Record<RequestHeader | (string & CustomHeader), string>;
+    /**
+     * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
+     *
+     * @see {@link https://hono.dev/docs/api/request#parsebody}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.parseBody()
+     * })
+     * ```
+     */
+    parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
+    parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
+    /**
+     * `.json()` can parse Request body of type `application/json`
+     *
+     * @see {@link https://hono.dev/docs/api/request#json}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.json()
+     * })
+     * ```
+     */
+    json<T = any>(): Promise<T>;
+    /**
+     * `.text()` can parse Request body of type `text/plain`
+     *
+     * @see {@link https://hono.dev/docs/api/request#text}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.text()
+     * })
+     * ```
+     */
+    text(): Promise<string>;
+    /**
+     * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+     *
+     * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.arrayBuffer()
+     * })
+     * ```
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Parses the request body as a `Blob`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.blob();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#blob
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Parses the request body as `FormData`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.formData();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#formdata
+     */
+    formData(): Promise<FormData>;
+    /**
+     * Adds validated data to the request.
+     *
+     * @param target - The target of the validation.
+     * @param data - The validated data to add.
+     */
+    addValidatedData(target: keyof ValidationTargets, data: {}): void;
+    /**
+     * Gets validated data from the request.
+     *
+     * @param target - The target of the validation.
+     * @returns The validated data.
+     *
+     * @see https://hono.dev/docs/api/request#valid
+     */
+    valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
+    /**
+     * `.url()` can get the request url strings.
+     *
+     * @see {@link https://hono.dev/docs/api/request#url}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const url = c.req.url // `http://localhost:8787/about/me`
+     *   ...
+     * })
+     * ```
+     */
+    get url(): string;
+    /**
+     * `.method()` can get the method name of the request.
+     *
+     * @see {@link https://hono.dev/docs/api/request#method}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const method = c.req.method // `GET`
+     * })
+     * ```
+     */
+    get method(): string;
+    /**
+     * `.matchedRoutes()` can return a matched route in the handler
+     *
+     * @deprecated
+     *
+     * Use matchedRoutes helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+     *
+     * @example
+     * ```ts
+     * app.use('*', async function logger(c, next) {
+     *   await next()
+     *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+     *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+     *     console.log(
+     *       method,
+     *       ' ',
+     *       path,
+     *       ' '.repeat(Math.max(10 - path.length, 0)),
+     *       name,
+     *       i === c.req.routeIndex ? '<- respond from here' : ''
+     *     )
+     *   })
+     * })
+     * ```
+     */
+    get matchedRoutes(): RouterRoute[];
+    /**
+     * `routePath()` can retrieve the path registered within the handler
+     *
+     * @deprecated
+     *
+     * Use routePath helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#routepath}
+     *
+     * @example
+     * ```ts
+     * app.get('/posts/:id', (c) => {
+     *   return c.json({ path: c.req.routePath })
+     * })
+     * ```
+     */
+    get routePath(): string;
+}
+/**
+ * Clones a HonoRequest's underlying raw Request object.
+ *
+ * This utility handles both consumed and unconsumed request bodies:
+ * - If the request body hasn't been consumed, it uses the native `clone()` method
+ * - If the request body has been consumed, it reconstructs a new Request using cached body data
+ *
+ * This is particularly useful when you need to:
+ * - Process the same request body multiple times
+ * - Pass requests to external services after validation
+ *
+ * @param req - The HonoRequest object to clone
+ * @returns A Promise that resolves to a new Request object with the same properties
+ * @throws {HTTPException} If the request body was consumed directly via `req.raw`
+ *   without using HonoRequest methods (e.g., `req.json()`, `req.text()`), making it
+ *   impossible to reconstruct the body from cache
+ *
+ * @example
+ * ```ts
+ * // Clone after consuming the body (e.g., after validation)
+ * app.post('/forward',
+ *   validator('json', (data) => data),
+ *   async (c) => {
+ *     const validated = c.req.valid('json')
+ *     // Body has been consumed, but cloneRawRequest still works
+ *     const clonedReq = await cloneRawRequest(c.req)
+ *     return fetch('http://backend-service.com', clonedReq)
+ *   }
+ * )
+ * ```
+ */
+export declare const cloneRawRequest: (req: HonoRequest) => Promise<Request>;
+export {};
+//# sourceMappingURL=request.d.ts.map

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/request.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@hono/hono/4.10.7/src/request.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EACV,KAAK,EACL,mBAAmB,EACnB,gBAAgB,EAChB,SAAS,EACT,cAAc,EACd,WAAW,EACX,iBAAiB,EAClB,MAAM,YAAY,CAAA;AAEnB,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAGrE,KAAK,IAAI,GAAG;IACV,IAAI,EAAE,GAAG,CAAA;IACT,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,WAAW,CAAA;IACxB,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,QAAQ,CAAA;CACnB,CAAA;AACD,KAAK,SAAS,GAAG,OAAO,CAAC,IAAI,GAAG;IAAE,UAAU,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA;AASzD,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAAE,CAAC,SAAS,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE;;IA+UtE,CAAC,gBAAgB,CAAC;IA9UtB;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,OAAO,CAAA;IAIZ,UAAU,EAAE,MAAM,CAAI;IACtB;;;;;;;;;;;OAWG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,SAAS,CAAK;gBAGvB,OAAO,EAAE,OAAO,EAChB,IAAI,GAAE,MAAY,EAClB,WAAW,GAAE,MAAM,CAAC,CAAC,OAAO,EAAE,WAAW,CAAC,CAAQ;IAQpD;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,SAAS,GAAG,MAAM,CAAC,GAAG,GAAG,KAAK,GAAG,EAAE,GAAG,MAAM;IACjG,KAAK,CAAC,EAAE,SAAS,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAC1E,GAAG,EAAE,EAAE,GACN,MAAM,GAAG,SAAS;IACrB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IACtC,KAAK,CAAC,EAAE,SAAS,MAAM,GAAG,CAAC,KAAK,QAAQ,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IA6B9F;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IACtC,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAK/B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAC1C,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAKnC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS;IAC/C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IACxC,MAAM,IAAI,MAAM,CAAC,aAAa,GAAG,CAAC,MAAM,GAAG,YAAY,CAAC,EAAE,MAAM,CAAC;IAajE;;;;;;;;;;;OAWG;IACG,SAAS,CAAC,OAAO,SAAS,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC,SAAS,QAAQ,CAAC,OAAO,CAAC,EACpF,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,CAAC,CAAC;IACP,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA0BpF;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,CAAC,GAAG,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC;IAI3B;;;;;;;;;;;OAWG;IACH,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAIvB;;;;;;;;;;;OAWG;IACH,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAInC;;;;;;;;;OASG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB;;;;;;;;;OASG;IACH,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI7B;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,iBAAiB,EAAE,IAAI,EAAE,EAAE;IAI1D;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,iBAAiB,EAAE,MAAM,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC;IAKxF;;;;;;;;;;;;OAYG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;;;;;;;;;;OAWG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAMD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,IAAI,aAAa,IAAI,WAAW,EAAE,CAEjC;IAED;;;;;;;;;;;;;;;OAeG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,eAAe,GAAU,KAAK,WAAW,KAAG,OAAO,CAAC,OAAO,CA6BvE,CAAA"}

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/request.js ADDED Viewed

@@ -0,0 +1,370 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _HonoRequest_instances, _HonoRequest_validatedData, _HonoRequest_matchResult, _HonoRequest_getDecodedParam, _HonoRequest_getAllDecodedParams, _HonoRequest_getParamValue, _HonoRequest_cachedBody;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HTTPException } from './http-exception.js';
+import { GET_MATCH_RESULT } from './request/constants.js';
+import { parseBody } from './utils/body.js';
+import { decodeURIComponent_, getQueryParam, getQueryParams, tryDecode } from './utils/url.js';
+const tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
+export class HonoRequest {
+    constructor(request, path = '/', matchResult = [[]]) {
+        _HonoRequest_instances.add(this);
+        /**
+         * `.raw` can get the raw Request object.
+         *
+         * @see {@link https://hono.dev/docs/api/request#raw}
+         *
+         * @example
+         * ```ts
+         * // For Cloudflare Workers
+         * app.post('/', async (c) => {
+         *   const metadata = c.req.raw.cf?.hostMetadata?
+         *   ...
+         * })
+         * ```
+         */
+        Object.defineProperty(this, "raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _HonoRequest_validatedData.set(this, void 0); // Short name of validatedData
+        _HonoRequest_matchResult.set(this, void 0);
+        Object.defineProperty(this, "routeIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /**
+         * `.path` can get the pathname of the request.
+         *
+         * @see {@link https://hono.dev/docs/api/request#path}
+         *
+         * @example
+         * ```ts
+         * app.get('/about/me', (c) => {
+         *   const pathname = c.req.path // `/about/me`
+         * })
+         * ```
+         */
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bodyCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        _HonoRequest_cachedBody.set(this, (key) => {
+            const { bodyCache, raw } = this;
+            const cachedBody = bodyCache[key];
+            if (cachedBody) {
+                return cachedBody;
+            }
+            const anyCachedKey = Object.keys(bodyCache)[0];
+            if (anyCachedKey) {
+                return bodyCache[anyCachedKey].then((body) => {
+                    if (anyCachedKey === 'json') {
+                        body = JSON.stringify(body);
+                    }
+                    return new Response(body)[key]();
+                });
+            }
+            return (bodyCache[key] = raw[key]());
+        }
+        /**
+         * `.json()` can parse Request body of type `application/json`
+         *
+         * @see {@link https://hono.dev/docs/api/request#json}
+         *
+         * @example
+         * ```ts
+         * app.post('/entry', async (c) => {
+         *   const body = await c.req.json()
+         * })
+         * ```
+         */
+        );
+        this.raw = request;
+        this.path = path;
+        __classPrivateFieldSet(this, _HonoRequest_matchResult, matchResult, "f");
+        __classPrivateFieldSet(this, _HonoRequest_validatedData, {}, "f");
+    }
+    param(key) {
+        return key ? __classPrivateFieldGet(this, _HonoRequest_instances, "m", _HonoRequest_getDecodedParam).call(this, key) : __classPrivateFieldGet(this, _HonoRequest_instances, "m", _HonoRequest_getAllDecodedParams).call(this);
+    }
+    query(key) {
+        return getQueryParam(this.url, key);
+    }
+    queries(key) {
+        return getQueryParams(this.url, key);
+    }
+    header(name) {
+        if (name) {
+            return this.raw.headers.get(name) ?? undefined;
+        }
+        const headerData = {};
+        this.raw.headers.forEach((value, key) => {
+            headerData[key] = value;
+        });
+        return headerData;
+    }
+    async parseBody(options) {
+        return (this.bodyCache.parsedBody ??= await parseBody(this, options));
+    }
+    /**
+     * `.json()` can parse Request body of type `application/json`
+     *
+     * @see {@link https://hono.dev/docs/api/request#json}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.json()
+     * })
+     * ```
+     */
+    json() {
+        return __classPrivateFieldGet(this, _HonoRequest_cachedBody, "f").call(this, 'text').then((text) => JSON.parse(text));
+    }
+    /**
+     * `.text()` can parse Request body of type `text/plain`
+     *
+     * @see {@link https://hono.dev/docs/api/request#text}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.text()
+     * })
+     * ```
+     */
+    text() {
+        return __classPrivateFieldGet(this, _HonoRequest_cachedBody, "f").call(this, 'text');
+    }
+    /**
+     * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+     *
+     * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.arrayBuffer()
+     * })
+     * ```
+     */
+    arrayBuffer() {
+        return __classPrivateFieldGet(this, _HonoRequest_cachedBody, "f").call(this, 'arrayBuffer');
+    }
+    /**
+     * Parses the request body as a `Blob`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.blob();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#blob
+     */
+    blob() {
+        return __classPrivateFieldGet(this, _HonoRequest_cachedBody, "f").call(this, 'blob');
+    }
+    /**
+     * Parses the request body as `FormData`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.formData();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#formdata
+     */
+    formData() {
+        return __classPrivateFieldGet(this, _HonoRequest_cachedBody, "f").call(this, 'formData');
+    }
+    /**
+     * Adds validated data to the request.
+     *
+     * @param target - The target of the validation.
+     * @param data - The validated data to add.
+     */
+    addValidatedData(target, data) {
+        __classPrivateFieldGet(this, _HonoRequest_validatedData, "f")[target] = data;
+    }
+    valid(target) {
+        return __classPrivateFieldGet(this, _HonoRequest_validatedData, "f")[target];
+    }
+    /**
+     * `.url()` can get the request url strings.
+     *
+     * @see {@link https://hono.dev/docs/api/request#url}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const url = c.req.url // `http://localhost:8787/about/me`
+     *   ...
+     * })
+     * ```
+     */
+    get url() {
+        return this.raw.url;
+    }
+    /**
+     * `.method()` can get the method name of the request.
+     *
+     * @see {@link https://hono.dev/docs/api/request#method}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const method = c.req.method // `GET`
+     * })
+     * ```
+     */
+    get method() {
+        return this.raw.method;
+    }
+    get [(_HonoRequest_validatedData = new WeakMap(), _HonoRequest_matchResult = new WeakMap(), _HonoRequest_cachedBody = new WeakMap(), _HonoRequest_instances = new WeakSet(), _HonoRequest_getDecodedParam = function _HonoRequest_getDecodedParam(key) {
+        const paramKey = __classPrivateFieldGet(this, _HonoRequest_matchResult, "f")[0][this.routeIndex][1][key];
+        const param = __classPrivateFieldGet(this, _HonoRequest_instances, "m", _HonoRequest_getParamValue).call(this, paramKey);
+        return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
+    }, _HonoRequest_getAllDecodedParams = function _HonoRequest_getAllDecodedParams() {
+        const decoded = {};
+        const keys = Object.keys(__classPrivateFieldGet(this, _HonoRequest_matchResult, "f")[0][this.routeIndex][1]);
+        for (const key of keys) {
+            const value = __classPrivateFieldGet(this, _HonoRequest_instances, "m", _HonoRequest_getParamValue).call(this, __classPrivateFieldGet(this, _HonoRequest_matchResult, "f")[0][this.routeIndex][1][key]);
+            if (value !== undefined) {
+                decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+            }
+        }
+        return decoded;
+    }, _HonoRequest_getParamValue = function _HonoRequest_getParamValue(paramKey) {
+        return __classPrivateFieldGet(this, _HonoRequest_matchResult, "f")[1] ? __classPrivateFieldGet(this, _HonoRequest_matchResult, "f")[1][paramKey] : paramKey;
+    }, GET_MATCH_RESULT)]() {
+        return __classPrivateFieldGet(this, _HonoRequest_matchResult, "f");
+    }
+    /**
+     * `.matchedRoutes()` can return a matched route in the handler
+     *
+     * @deprecated
+     *
+     * Use matchedRoutes helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+     *
+     * @example
+     * ```ts
+     * app.use('*', async function logger(c, next) {
+     *   await next()
+     *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+     *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+     *     console.log(
+     *       method,
+     *       ' ',
+     *       path,
+     *       ' '.repeat(Math.max(10 - path.length, 0)),
+     *       name,
+     *       i === c.req.routeIndex ? '<- respond from here' : ''
+     *     )
+     *   })
+     * })
+     * ```
+     */
+    get matchedRoutes() {
+        return __classPrivateFieldGet(this, _HonoRequest_matchResult, "f")[0].map(([[, route]]) => route);
+    }
+    /**
+     * `routePath()` can retrieve the path registered within the handler
+     *
+     * @deprecated
+     *
+     * Use routePath helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#routepath}
+     *
+     * @example
+     * ```ts
+     * app.get('/posts/:id', (c) => {
+     *   return c.json({ path: c.req.routePath })
+     * })
+     * ```
+     */
+    get routePath() {
+        return __classPrivateFieldGet(this, _HonoRequest_matchResult, "f")[0].map(([[, route]]) => route)[this.routeIndex].path;
+    }
+}
+/**
+ * Clones a HonoRequest's underlying raw Request object.
+ *
+ * This utility handles both consumed and unconsumed request bodies:
+ * - If the request body hasn't been consumed, it uses the native `clone()` method
+ * - If the request body has been consumed, it reconstructs a new Request using cached body data
+ *
+ * This is particularly useful when you need to:
+ * - Process the same request body multiple times
+ * - Pass requests to external services after validation
+ *
+ * @param req - The HonoRequest object to clone
+ * @returns A Promise that resolves to a new Request object with the same properties
+ * @throws {HTTPException} If the request body was consumed directly via `req.raw`
+ *   without using HonoRequest methods (e.g., `req.json()`, `req.text()`), making it
+ *   impossible to reconstruct the body from cache
+ *
+ * @example
+ * ```ts
+ * // Clone after consuming the body (e.g., after validation)
+ * app.post('/forward',
+ *   validator('json', (data) => data),
+ *   async (c) => {
+ *     const validated = c.req.valid('json')
+ *     // Body has been consumed, but cloneRawRequest still works
+ *     const clonedReq = await cloneRawRequest(c.req)
+ *     return fetch('http://backend-service.com', clonedReq)
+ *   }
+ * )
+ * ```
+ */
+export const cloneRawRequest = async (req) => {
+    if (!req.raw.bodyUsed) {
+        return req.raw.clone();
+    }
+    const cacheKey = Object.keys(req.bodyCache)[0];
+    if (!cacheKey) {
+        throw new HTTPException(500, {
+            message: 'Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly.',
+        });
+    }
+    const requestInit = {
+        body: await req[cacheKey](),
+        cache: req.raw.cache,
+        credentials: req.raw.credentials,
+        headers: req.header(),
+        integrity: req.raw.integrity,
+        keepalive: req.raw.keepalive,
+        method: req.method,
+        mode: req.raw.mode,
+        redirect: req.raw.redirect,
+        referrer: req.raw.referrer,
+        referrerPolicy: req.raw.referrerPolicy,
+        signal: req.raw.signal,
+    };
+    return new Request(req.url, requestInit);
+};