@kerebron/extension-server-hono 0.4.26 → 0.4.27

package/esm/deps/jsr.io/@hono/hono/4.11.1/src/hono-base.d.ts

@@ -1,221 +0,0 @@
-/**
- * @module
- * This module is the base module for the Hono object.
- */
-import { Context } from './context.js';
-import type { ExecutionContext } from './context.js';
-import type { Router } from './router.js';
-import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types.js';
-type GetPath<E extends Env> = (request: Request, options?: {
-    env?: E['Bindings'];
-}) => string;
-export type HonoOptions<E extends Env> = {
-    /**
-     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#strict-mode}
-     *
-     * @default true
-     */
-    strict?: boolean;
-    /**
-     * `router` option specifies which router to use.
-     *
-     * @see {@link https://hono.dev/docs/api/hono#router-option}
-     *
-     * @example
-     * ```ts
-     * const app = new Hono({ router: new RegExpRouter() })
-     * ```
-     */
-    router?: Router<[H, RouterRoute]>;
-    /**
-     * `getPath` can handle the host header value.
-     *
-     * @see {@link https://hono.dev/docs/api/routing#routing-with-host-header-value}
-     *
-     * @example
-     * ```ts
-     * const app = new Hono({
-     *  getPath: (req) =>
-     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
-     * })
-     *
-     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
-     *
-     * // A following request will match the route:
-     * // new Request('http://www1.example.com/hello', {
-     * //  headers: { host: 'www1.example.com' },
-     * // })
-     * ```
-     */
-    getPath?: GetPath<E>;
-};
-type MountOptionHandler = (c: Context) => unknown;
-type MountReplaceRequest = (originalRequest: Request) => Request;
-type MountOptions = MountOptionHandler | {
-    optionHandler?: MountOptionHandler;
-    replaceRequest?: MountReplaceRequest | false;
-};
-declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
-    #private;
-    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
-    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
-    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
-    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
-    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
-    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
-    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
-    on: OnHandlerInterface<E, S, BasePath>;
-    use: MiddlewareHandlerInterface<E, S, BasePath>;
-    router: Router<[H, RouterRoute]>;
-    readonly getPath: GetPath<E>;
-    private _basePath;
-    routes: RouterRoute[];
-    constructor(options?: HonoOptions<E>);
-    private errorHandler;
-    /**
-     * `.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<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
-    /**
-     * `.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<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
-    /**
-     * `.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: ErrorHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
-    /**
-     * `.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: NotFoundHandler<E>) => Hono<E, S, BasePath, CurrentPath>;
-    /**
-     * `.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: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Hono<E, S, BasePath, CurrentPath>;
-    /**
-     * `.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: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.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: RequestInfo | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.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: () => void;
-}
-export { Hono as HonoBase };
-//# sourceMappingURL=hono-base.d.ts.map

package/esm/deps/jsr.io/@hono/hono/4.11.1/src/hono-base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hono-base.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@hono/hono/4.11.1/src/hono-base.ts"],"names":[],"mappings":"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"}

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

@@ -1,391 +0,0 @@
-/**
- * @module
- * This module is the base module for the Hono object.
- */
-/* 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 {
-    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 = {}) {
-        // 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') {
-                    this.#path = args1;
-                }
-                else {
-                    this.#addRoute(method, this.#path, args1);
-                }
-                args.forEach((handler) => {
-                    this.#addRoute(method, this.#path, handler);
-                });
-                return this;
-            };
-        });
-        // Implementation of app.on(method, path, ...handlers[])
-        this.on = (method, path, ...handlers) => {
-            for (const p of [path].flat()) {
-                this.#path = p;
-                for (const m of [method].flat()) {
-                    handlers.map((handler) => {
-                        this.#addRoute(m.toUpperCase(), this.#path, handler);
-                    });
-                }
-            }
-            return this;
-        };
-        // Implementation of app.use(...handlers[]) or app.use(path, ...handlers[])
-        this.use = (arg1, ...handlers) => {
-            if (typeof arg1 === 'string') {
-                this.#path = arg1;
-            }
-            else {
-                this.#path = '*';
-                handlers.unshift(arg1);
-            }
-            handlers.forEach((handler) => {
-                this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
-            });
-            return this;
-        };
-        const { strict, ...optionsWithoutStrict } = options;
-        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.
-     *
-     * @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;
-            }
-            subApp.#addRoute(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 = 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.
-     *
-     * @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();
-        };
-        this.#addRoute(METHOD_NAME_ALL, mergePath(path, '*'), handler);
-        return this;
-    }
-    #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);
-    }
-    #handleError(err, c) {
-        if (err instanceof Error) {
-            return this.errorHandler(err, c);
-        }
-        throw err;
-    }
-    #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);
-                });
-            }
-            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));
-        }
-        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.11.1/src/http-exception.d.ts

@@ -1,60 +0,0 @@
-/**
- * @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.11.1/src/http-exception.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http-exception.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@hono/hono/4.11.1/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"}