@kerebron/extension-server-hono 0.4.8 → 0.4.10

package/esm/deps/jsr.io/@hono/hono/4.10.7/src/helper/websocket/index.js

@@ -2,64 +2,31 @@
  * @module
  * WebSocket Helper for Hono.
  */
-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 _WSContext_init;
 /**
  * A context for controlling WebSockets
  */
 export class WSContext {
+    #init;
     constructor(init) {
-        _WSContext_init.set(this, void 0);
-        Object.defineProperty(this, "raw", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "binaryType", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'arraybuffer'
-        });
-        Object.defineProperty(this, "url", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "protocol", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        __classPrivateFieldSet(this, _WSContext_init, init, "f");
+        this.#init = init;
         this.raw = init.raw;
         this.url = init.url ? new URL(init.url) : null;
         this.protocol = init.protocol ?? null;
     }
     send(source, options) {
-        __classPrivateFieldGet(this, _WSContext_init, "f").send(source, options ?? {});
+        this.#init.send(source, options ?? {});
     }
+    raw;
+    binaryType = 'arraybuffer';
     get readyState() {
-        return __classPrivateFieldGet(this, _WSContext_init, "f").readyState;
+        return this.#init.readyState;
     }
+    url;
+    protocol;
     close(code, reason) {
-        __classPrivateFieldGet(this, _WSContext_init, "f").close(code, reason);
+        this.#init.close(code, reason);
     }
 }
-_WSContext_init = new WeakMap();
 export const createWSMessageEvent = (source) => {
     return new MessageEvent('message', {
         data: source,

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

@@ -2,18 +2,6 @@
  * @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';
@@ -32,235 +20,38 @@ const errorHandler = (err, c) => {
     return c.text('Internal Server Error', 500);
 };
 class Hono {
+    get;
+    post;
+    put;
+    delete;
+    options;
+    patch;
+    all;
+    on;
+    use;
+    /*
+      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.
+    */
+    router;
+    getPath;
+    // Cannot use `#` because it requires visibility at JavaScript runtime.
+    _basePath = '/';
+    #path = '/';
+    routes = [];
     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");
+                    this.#path = args1;
                 }
                 else {
-                    __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, method, __classPrivateFieldGet(this, _Hono_path, "f"), args1);
+                    this.#addRoute(method, this.#path, args1);
                 }
                 args.forEach((handler) => {
-                    __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, method, __classPrivateFieldGet(this, _Hono_path, "f"), handler);
+                    this.#addRoute(method, this.#path, handler);
                 });
                 return this;
             };
@@ -268,10 +59,10 @@ class Hono {
         // Implementation of app.on(method, path, ...handlers[])
         this.on = (method, path, ...handlers) => {
             for (const p of [path].flat()) {
-                __classPrivateFieldSet(this, _Hono_path, p, "f");
+                this.#path = p;
                 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);
+                        this.#addRoute(m.toUpperCase(), this.#path, handler);
                     });
                 }
             }
@@ -280,14 +71,14 @@ class Hono {
         // Implementation of app.use(...handlers[]) or app.use(path, ...handlers[])
         this.use = (arg1, ...handlers) => {
             if (typeof arg1 === 'string') {
-                __classPrivateFieldSet(this, _Hono_path, arg1, "f");
+                this.#path = arg1;
             }
             else {
-                __classPrivateFieldSet(this, _Hono_path, '*', "f");
+                this.#path = '*';
                 handlers.unshift(arg1);
             }
             handlers.forEach((handler) => {
-                __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, METHOD_NAME_ALL, __classPrivateFieldGet(this, _Hono_path, "f"), handler);
+                this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
             });
             return this;
         };
@@ -295,6 +86,19 @@ class Hono {
         Object.assign(this, optionsWithoutStrict);
         this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
     }
+    #clone() {
+        const clone = new Hono({
+            router: this.router,
+            getPath: this.getPath,
+        });
+        clone.errorHandler = this.errorHandler;
+        clone.#notFoundHandler = this.#notFoundHandler;
+        clone.routes = this.routes;
+        return clone;
+    }
+    #notFoundHandler = notFoundHandler;
+    // Cannot use `#` because it requires visibility at JavaScript runtime.
+    errorHandler = errorHandler;
     /**
      * `.route()` allows grouping other Hono instance in routes.
      *
@@ -324,7 +128,7 @@ class Hono {
                 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);
+            subApp.#addRoute(r.method, r.path, handler);
         });
         return this;
     }
@@ -342,10 +146,49 @@ class Hono {
      * ```
      */
     basePath(path) {
-        const subApp = __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_clone).call(this);
+        const subApp = this.#clone();
         subApp._basePath = mergePath(this._basePath, path);
         return subApp;
     }
+    /**
+     * `.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)
+     * })
+     * ```
+     */
+    onError = (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)
+     * })
+     * ```
+     */
+    notFound = (handler) => {
+        this.#notFoundHandler = handler;
+        return this;
+    };
     /**
      * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
      *
@@ -426,73 +269,123 @@ class Hono {
             }
             await next();
         };
-        __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_addRoute).call(this, METHOD_NAME_ALL, mergePath(path, '*'), handler);
+        this.#addRoute(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')))();
+    #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);
     }
-    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);
+    #handleError(err, c) {
+        if (err instanceof Error) {
+            return this.errorHandler(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);
+        throw err;
     }
-    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()`?');
+    #dispatch(request, executionCtx, env, method) {
+        // Handle HEAD method
+        if (method === 'HEAD') {
+            return (async () => new Response(null, await this.#dispatch(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: this.#notFoundHandler,
+        });
+        // 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 this.#notFoundHandler(c);
+                });
             }
-            return context.res;
+            catch (err) {
+                return this.#handleError(err, c);
+            }
+            return res instanceof Promise
+                ? res
+                    .then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c)))
+                    .catch((err) => this.#handleError(err, c))
+                : res ?? this.#notFoundHandler(c);
         }
-        catch (err) {
-            return __classPrivateFieldGet(this, _Hono_instances, "m", _Hono_handleError).call(this, err, c);
+        const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+        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 this.#handleError(err, c);
+            }
+        })();
+    }
+    /**
+     * `.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
+     *
+     */
+    fetch = (request, ...rest) => {
+        return this.#dispatch(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
+     */
+    request = (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/
+     */
+    fire = () => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        addEventListener('fetch', (event) => {
+            event.respondWith(this.#dispatch(event.request, event, undefined, event.request.method));
+        });
+    };
+}
 export { Hono as HonoBase };

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

@@ -29,6 +29,8 @@
  * ```
  */
 export class HTTPException extends Error {
+    res;
+    status;
     /**
      * Creates an instance of `HTTPException`.
      * @param status - HTTP status code for the exception. Defaults to 500.
@@ -36,18 +38,6 @@ export class HTTPException extends Error {
      */
     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;
     }