@kerebron/extension-server-hono 0.4.5 → 0.4.6

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/hono-base.js

@@ -0,0 +1,498 @@
+/**
+ * @module
+ * This module is the base module for the Hono object.
+ */
+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 _Hono_instances, _a, _Hono_path, _Hono_clone, _Hono_notFoundHandler, _Hono_addRoute, _Hono_handleError, _Hono_dispatch;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { compose } from './compose.js';
+import { Context } from './context.js';
+import { METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE } from './router.js';
+import { COMPOSED_HANDLER } from './utils/constants.js';
+import { getPath, getPathNoStrict, mergePath } from './utils/url.js';
+const notFoundHandler = (c) => {
+    return c.text('404 Not Found', 404);
+};
+const errorHandler = (err, c) => {
+    if ('getResponse' in err) {
+        const res = err.getResponse();
+        return c.newResponse(res.body, res);
+    }
+    console.error(err);
+    return c.text('Internal Server Error', 500);
+};
+class Hono {
+    constructor(options = {}) {
+        _Hono_instances.add(this);
+        Object.defineProperty(this, "get", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "post", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "put", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "delete", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "patch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "all", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "on", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "use", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /*
+          This class is like an abstract class and does not have a router.
+          To use it, inherit the class and implement router in the constructor.
+        */
+        Object.defineProperty(this, "router", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "getPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Cannot use `#` because it requires visibility at JavaScript runtime.
+        Object.defineProperty(this, "_basePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: '/'
+        });
+        _Hono_path.set(this, '/');
+        Object.defineProperty(this, "routes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        _Hono_notFoundHandler.set(this, notFoundHandler
+        // Cannot use `#` because it requires visibility at JavaScript runtime.
+        );
+        // Cannot use `#` because it requires visibility at JavaScript runtime.
+        Object.defineProperty(this, "errorHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: errorHandler
+        });
+        /**
+         * `.onError()` handles an error and returns a customized Response.
+         *
+         * @see {@link https://hono.dev/docs/api/hono#error-handling}
+         *
+         * @param {ErrorHandler} handler - request Handler for error
+         * @returns {Hono} changed Hono instance
+         *
+         * @example
+         * ```ts
+         * app.onError((err, c) => {
+         *   console.error(`${err}`)
+         *   return c.text('Custom Error Message', 500)
+         * })
+         * ```
+         */
+        Object.defineProperty(this, "onError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (handler) => {
+                this.errorHandler = handler;
+                return this;
+            }
+        });
+        /**
+         * `.notFound()` allows you to customize a Not Found Response.
+         *
+         * @see {@link https://hono.dev/docs/api/hono#not-found}
+         *
+         * @param {NotFoundHandler} handler - request handler for not-found
+         * @returns {Hono} changed Hono instance
+         *
+         * @example
+         * ```ts
+         * app.notFound((c) => {
+         *   return c.text('Custom 404 Message', 404)
+         * })
+         * ```
+         */
+        Object.defineProperty(this, "notFound", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (handler) => {
+                __classPrivateFieldSet(this, _Hono_notFoundHandler, handler, "f");
+                return this;
+            }
+        });
+        /**
+         * `.fetch()` will be entry point of your app.
+         *
+         * @see {@link https://hono.dev/docs/api/hono#fetch}
+         *
+         * @param {Request} request - request Object of request
+         * @param {Env} Env - env Object
+         * @param {ExecutionContext} - context of execution
+         * @returns {Response | Promise<Response>} response of request
+         *
+         */
+        Object.defineProperty(this, "fetch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (request, ...rest) => {
+                return __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_dispatch).call(this, request, rest[1], rest[0], request.method);
+            }
+        });
+        /**
+         * `.request()` is a useful method for testing.
+         * You can pass a URL or pathname to send a GET request.
+         * app will return a Response object.
+         * ```ts
+         * test('GET /hello is ok', async () => {
+         *   const res = await app.request('/hello')
+         *   expect(res.status).toBe(200)
+         * })
+         * ```
+         * @see https://hono.dev/docs/api/hono#request
+         */
+        Object.defineProperty(this, "request", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (input, requestInit, Env, executionCtx) => {
+                if (input instanceof Request) {
+                    return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+                }
+                input = input.toString();
+                return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath('/', input)}`, requestInit), Env, executionCtx);
+            }
+        });
+        /**
+         * `.fire()` automatically adds a global fetch event listener.
+         * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+         * @deprecated
+         * Use `fire` from `hono/service-worker` instead.
+         * ```ts
+         * import { Hono } from 'hono'
+         * import { fire } from 'hono/service-worker'
+         *
+         * const app = new Hono()
+         * // ...
+         * fire(app)
+         * ```
+         * @see https://hono.dev/docs/api/hono#fire
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+         * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+         */
+        Object.defineProperty(this, "fire", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                addEventListener('fetch', (event) => {
+                    event.respondWith(__classPrivateFieldGet(this, _Hono_instances, "m", _Hono_dispatch).call(this, event.request, event, undefined, event.request.method));
+                });
+            }
+        });
+        // Implementation of app.get(...handlers[]) or app.get(path, ...handlers[])
+        const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+        allMethods.forEach((method) => {
+            this[method] = (args1, ...args) => {
+                if (typeof args1 === 'string') {
+                    __classPrivateFieldSet(this, _Hono_path, args1, "f");
+                }
+                else {
+                    __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, method, __classPrivateFieldGet(this, _Hono_path, "f"), args1);
+                }
+                args.forEach((handler) => {
+                    __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, method, __classPrivateFieldGet(this, _Hono_path, "f"), handler);
+                });
+                return this;
+            };
+        });
+        // Implementation of app.on(method, path, ...handlers[])
+        this.on = (method, path, ...handlers) => {
+            for (const p of [path].flat()) {
+                __classPrivateFieldSet(this, _Hono_path, p, "f");
+                for (const m of [method].flat()) {
+                    handlers.map((handler) => {
+                        __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, m.toUpperCase(), __classPrivateFieldGet(this, _Hono_path, "f"), handler);
+                    });
+                }
+            }
+            return this;
+        };
+        // Implementation of app.use(...handlers[]) or app.use(path, ...handlers[])
+        this.use = (arg1, ...handlers) => {
+            if (typeof arg1 === 'string') {
+                __classPrivateFieldSet(this, _Hono_path, arg1, "f");
+            }
+            else {
+                __classPrivateFieldSet(this, _Hono_path, '*', "f");
+                handlers.unshift(arg1);
+            }
+            handlers.forEach((handler) => {
+                __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, METHOD_NAME_ALL, __classPrivateFieldGet(this, _Hono_path, "f"), handler);
+            });
+            return this;
+        };
+        const { strict, ...optionsWithoutStrict } = options;
+        Object.assign(this, optionsWithoutStrict);
+        this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+    }
+    /**
+     * `.route()` allows grouping other Hono instance in routes.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#grouping}
+     *
+     * @param {string} path - base Path
+     * @param {Hono} app - other Hono instance
+     * @returns {Hono} routed Hono instance
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * const app2 = new Hono()
+     *
+     * app2.get("/user", (c) => c.text("user"))
+     * app.route("/api", app2) // GET /api/user
+     * ```
+     */
+    route(path, app) {
+        const subApp = this.basePath(path);
+        app.routes.map((r) => {
+            let handler;
+            if (app.errorHandler === errorHandler) {
+                handler = r.handler;
+            }
+            else {
+                handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+                handler[COMPOSED_HANDLER] = r.handler;
+            }
+            __classPrivateFieldGet(subApp, _Hono_instances, "m", _Hono_addRoute).call(subApp, r.method, r.path, handler);
+        });
+        return this;
+    }
+    /**
+     * `.basePath()` allows base paths to be specified.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#base-path}
+     *
+     * @param {string} path - base Path
+     * @returns {Hono} changed Hono instance
+     *
+     * @example
+     * ```ts
+     * const api = new Hono().basePath('/api')
+     * ```
+     */
+    basePath(path) {
+        const subApp = __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_clone).call(this);
+        subApp._basePath = mergePath(this._basePath, path);
+        return subApp;
+    }
+    /**
+     * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+     *
+     * @see {@link https://hono.dev/docs/api/hono#mount}
+     *
+     * @param {string} path - base Path
+     * @param {Function} applicationHandler - other Request Handler
+     * @param {MountOptions} [options] - options of `.mount()`
+     * @returns {Hono} mounted Hono instance
+     *
+     * @example
+     * ```ts
+     * import { Router as IttyRouter } from 'itty-router'
+     * import { Hono } from 'hono'
+     * // Create itty-router application
+     * const ittyRouter = IttyRouter()
+     * // GET /itty-router/hello
+     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+     *
+     * const app = new Hono()
+     * app.mount('/itty-router', ittyRouter.handle)
+     * ```
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * // Send the request to another application without modification.
+     * app.mount('/app', anotherApp, {
+     *   replaceRequest: (req) => req,
+     * })
+     * ```
+     */
+    mount(path, applicationHandler, options) {
+        // handle options
+        let replaceRequest;
+        let optionHandler;
+        if (options) {
+            if (typeof options === 'function') {
+                optionHandler = options;
+            }
+            else {
+                optionHandler = options.optionHandler;
+                if (options.replaceRequest === false) {
+                    replaceRequest = (request) => request;
+                }
+                else {
+                    replaceRequest = options.replaceRequest;
+                }
+            }
+        }
+        // prepare handlers for request
+        const getOptions = optionHandler
+            ? (c) => {
+                const options = optionHandler(c);
+                return Array.isArray(options) ? options : [options];
+            }
+            : (c) => {
+                let executionContext = undefined;
+                try {
+                    executionContext = c.executionCtx;
+                }
+                catch { } // Do nothing
+                return [c.env, executionContext];
+            };
+        replaceRequest ||= (() => {
+            const mergedPath = mergePath(this._basePath, path);
+            const pathPrefixLength = mergedPath === '/' ? 0 : mergedPath.length;
+            return (request) => {
+                const url = new URL(request.url);
+                url.pathname = url.pathname.slice(pathPrefixLength) || '/';
+                return new Request(url, request);
+            };
+        })();
+        const handler = async (c, next) => {
+            const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+            if (res) {
+                return res;
+            }
+            await next();
+        };
+        __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, METHOD_NAME_ALL, mergePath(path, '*'), handler);
+        return this;
+    }
+}
+_a = Hono, _Hono_path = new WeakMap(), _Hono_notFoundHandler = new WeakMap(), _Hono_instances = new WeakSet(), _Hono_clone = function _Hono_clone() {
+    const clone = new _a({
+        router: this.router,
+        getPath: this.getPath,
+    });
+    clone.errorHandler = this.errorHandler;
+    __classPrivateFieldSet(clone, _Hono_notFoundHandler, __classPrivateFieldGet(this, _Hono_notFoundHandler, "f"), "f");
+    clone.routes = this.routes;
+    return clone;
+}, _Hono_addRoute = function _Hono_addRoute(method, path, handler) {
+    method = method.toUpperCase();
+    path = mergePath(this._basePath, path);
+    const r = { basePath: this._basePath, path, method, handler };
+    this.router.add(method, path, [handler, r]);
+    this.routes.push(r);
+}, _Hono_handleError = function _Hono_handleError(err, c) {
+    if (err instanceof Error) {
+        return this.errorHandler(err, c);
+    }
+    throw err;
+}, _Hono_dispatch = function _Hono_dispatch(request, executionCtx, env, method) {
+    // Handle HEAD method
+    if (method === 'HEAD') {
+        return (async () => new Response(null, await __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_dispatch).call(this, request, executionCtx, env, 'GET')))();
+    }
+    const path = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path);
+    const c = new Context(request, {
+        path,
+        matchResult,
+        env,
+        executionCtx,
+        notFoundHandler: __classPrivateFieldGet(this, _Hono_notFoundHandler, "f"),
+    });
+    // Do not `compose` if it has only one handler
+    if (matchResult[0].length === 1) {
+        let res;
+        try {
+            res = matchResult[0][0][0][0](c, async () => {
+                c.res = await __classPrivateFieldGet(this, _Hono_notFoundHandler, "f").call(this, c);
+            });
+        }
+        catch (err) {
+            return __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_handleError).call(this, err, c);
+        }
+        return res instanceof Promise
+            ? res
+                .then((resolved) => resolved || (c.finalized ? c.res : __classPrivateFieldGet(this, _Hono_notFoundHandler, "f").call(this, c)))
+                .catch((err) => __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_handleError).call(this, err, c))
+            : res ?? __classPrivateFieldGet(this, _Hono_notFoundHandler, "f").call(this, c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, __classPrivateFieldGet(this, _Hono_notFoundHandler, "f"));
+    return (async () => {
+        try {
+            const context = await composed(c);
+            if (!context.finalized) {
+                throw new Error('Context is not finalized. Did you forget to return a Response object or `await next()`?');
+            }
+            return context.res;
+        }
+        catch (err) {
+            return __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_handleError).call(this, err, c);
+        }
+    })();
+};
+export { Hono as HonoBase };

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/http-exception.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @module
+ * This module provides the `HTTPException` class.
+ */
+import type { ContentfulStatusCode } from './utils/http-status.js';
+/**
+ * Options for creating an `HTTPException`.
+ * @property res - Optional response object to use.
+ * @property message - Optional custom error message.
+ * @property cause - Optional cause of the error.
+ */
+type HTTPExceptionOptions = {
+    res?: Response;
+    message?: string;
+    cause?: unknown;
+};
+/**
+ * `HTTPException` must be used when a fatal error such as authentication failure occurs.
+ *
+ * @see {@link https://hono.dev/docs/api/exception}
+ *
+ * @param {StatusCode} status - status code of HTTPException
+ * @param {HTTPExceptionOptions} options - options of HTTPException
+ * @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
+ * @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
+ * @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
+ *
+ * @example
+ * ```ts
+ * import { HTTPException } from 'hono/http-exception'
+ *
+ * // ...
+ *
+ * app.post('/auth', async (c, next) => {
+ *   // authentication
+ *   if (authorized === false) {
+ *     throw new HTTPException(401, { message: 'Custom error message' })
+ *   }
+ *   await next()
+ * })
+ * ```
+ */
+export declare class HTTPException extends Error {
+    readonly res?: Response;
+    readonly status: ContentfulStatusCode;
+    /**
+     * Creates an instance of `HTTPException`.
+     * @param status - HTTP status code for the exception. Defaults to 500.
+     * @param options - Additional options for the exception.
+     */
+    constructor(status?: ContentfulStatusCode, options?: HTTPExceptionOptions);
+    /**
+     * Returns the response object associated with the exception.
+     * If a response object is not provided, a new response is created with the error message and status code.
+     * @returns The response object.
+     */
+    getResponse(): Response;
+}
+export {};
+//# sourceMappingURL=http-exception.d.ts.map

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/http-exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-exception.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@hono/hono/4.10.7/src/http-exception.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAElE;;;;;GAKG;AACH,KAAK,oBAAoB,GAAG;IAC1B,GAAG,CAAC,EAAE,QAAQ,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;IAErC;;;;OAIG;gBACS,MAAM,GAAE,oBAA0B,EAAE,OAAO,CAAC,EAAE,oBAAoB;IAM9E;;;;OAIG;IACH,WAAW,IAAI,QAAQ;CAYxB"}

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/http-exception.js

@@ -0,0 +1,71 @@
+/**
+ * @module
+ * This module provides the `HTTPException` class.
+ */
+/**
+ * `HTTPException` must be used when a fatal error such as authentication failure occurs.
+ *
+ * @see {@link https://hono.dev/docs/api/exception}
+ *
+ * @param {StatusCode} status - status code of HTTPException
+ * @param {HTTPExceptionOptions} options - options of HTTPException
+ * @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
+ * @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
+ * @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
+ *
+ * @example
+ * ```ts
+ * import { HTTPException } from 'hono/http-exception'
+ *
+ * // ...
+ *
+ * app.post('/auth', async (c, next) => {
+ *   // authentication
+ *   if (authorized === false) {
+ *     throw new HTTPException(401, { message: 'Custom error message' })
+ *   }
+ *   await next()
+ * })
+ * ```
+ */
+export class HTTPException extends Error {
+    /**
+     * Creates an instance of `HTTPException`.
+     * @param status - HTTP status code for the exception. Defaults to 500.
+     * @param options - Additional options for the exception.
+     */
+    constructor(status = 500, options) {
+        super(options?.message, { cause: options?.cause });
+        Object.defineProperty(this, "res", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.res = options?.res;
+        this.status = status;
+    }
+    /**
+     * Returns the response object associated with the exception.
+     * If a response object is not provided, a new response is created with the error message and status code.
+     * @returns The response object.
+     */
+    getResponse() {
+        if (this.res) {
+            const newResponse = new Response(this.res.body, {
+                status: this.status,
+                headers: this.res.headers,
+            });
+            return newResponse;
+        }
+        return new Response(this.message, {
+            status: this.status,
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare const GET_MATCH_RESULT: symbol;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@hono/hono/4.10.7/src/request/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAE,MAAiB,CAAA"}

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

@@ -0,0 +1 @@
+export const GET_MATCH_RESULT = Symbol();