@versori/run 0.0.1-alpha.2 → 0.0.1-alpha.3

package/esm/deps/deno.land/x/oak@v17.1.4/application.js

@@ -0,0 +1,526 @@
+// Copyright 2018-2025 the oak authors. All rights reserved. MIT license.
+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 __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 _Application_instances, _Application_composedMiddleware, _Application_contextOptions, _Application_contextState, _Application_keys, _Application_middleware, _Application_serverConstructor, _Application_getComposed, _Application_getContextState, _Application_handleError, _Application_handleRequest;
+/**
+ * Contains the core concept of oak, the middleware application. Typical usage
+ * is the creation of an application instance, registration of middleware, and
+ * then starting to listen for requests.
+ *
+ * # Example
+ *
+ * ```ts
+ * import { Application } from "jsr:@oak/oak/application";
+ *
+ * const app = new Application();
+ * app.use((ctx) => {
+ *   ctx.response.body = "hello world!";
+ * });
+ *
+ * app.listen({ port: 8080 });
+ * ```
+ *
+ * @module
+ */
+import * as dntShim from "../../../../_dnt.shims.js";
+import { Context } from "./context.js";
+import { assert, KeyStack, STATUS_TEXT } from "./deps.js";
+import { compose, isMiddlewareObject, } from "./middleware.js";
+import { cloneState } from "./utils/clone_state.js";
+import { createPromiseWithResolvers } from "./utils/create_promise_with_resolvers.js";
+import { isBun, isNetAddr, isNode } from "./utils/type_guards.js";
+const ADDR_REGEXP = /^\[?([^\]]*)\]?:([0-9]{1,5})$/;
+let DefaultServerCtor;
+let NativeRequestCtor;
+/** An event that occurs when the application closes. */
+export class ApplicationCloseEvent extends Event {
+    constructor(eventInitDict) {
+        super("close", eventInitDict);
+    }
+}
+/** An event that occurs when an application error occurs.
+ *
+ * When the error occurs related to the handling of a request, the `.context`
+ * property will be populated.
+ */
+export class ApplicationErrorEvent extends ErrorEvent {
+    constructor(eventInitDict) {
+        super("error", eventInitDict);
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = eventInitDict.context;
+    }
+}
+function logErrorListener({ error, context }) {
+    if (error instanceof Error) {
+        console.error(`[uncaught application error]: ${error.name} - ${error.message}`);
+    }
+    else {
+        console.error(`[uncaught application error]\n`, error);
+    }
+    if (context) {
+        let url;
+        try {
+            url = context.request.url.toString();
+        }
+        catch {
+            url = "[malformed url]";
+        }
+        console.error(`\nrequest:`, {
+            url,
+            method: context.request.method,
+            hasBody: context.request.hasBody,
+        });
+        console.error(`response:`, {
+            status: context.response.status,
+            type: context.response.type,
+            hasBody: !!context.response.body,
+            writable: context.response.writable,
+        });
+    }
+    if (error instanceof Error && error.stack) {
+        console.error(`\n${error.stack.split("\n").slice(1).join("\n")}`);
+    }
+}
+/**
+ * An event that occurs when the application starts listening for requests.
+ */
+export class ApplicationListenEvent extends Event {
+    constructor(eventInitDict) {
+        super("listen", eventInitDict);
+        Object.defineProperty(this, "hostname", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "port", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "secure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "serverType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.hostname = eventInitDict.hostname;
+        this.listener = eventInitDict.listener;
+        this.port = eventInitDict.port;
+        this.secure = eventInitDict.secure;
+        this.serverType = eventInitDict.serverType;
+    }
+}
+/** A class which registers middleware (via `.use()`) and then processes
+ * inbound requests against that middleware (via `.listen()`).
+ *
+ * The `context.state` can be typed via passing a generic argument when
+ * constructing an instance of `Application`. It can also be inferred by setting
+ * the {@linkcode ApplicationOptions.state} option when constructing the
+ * application.
+ *
+ * ### Basic example
+ *
+ * ```ts
+ * import { Application } from "jsr:@oak/oak/application";
+ *
+ * const app = new Application();
+ *
+ * app.use((ctx, next) => {
+ *   // called on each request with the context (`ctx`) of the request,
+ *   // response, and other data.
+ *   // `next()` is use to modify the flow control of the middleware stack.
+ * });
+ *
+ * app.listen({ port: 8080 });
+ * ```
+ *
+ * @template AS the type of the application state which extends
+ *              {@linkcode State} and defaults to a simple string record.
+ */
+// deno-lint-ignore no-explicit-any
+export class Application extends EventTarget {
+    /** A set of keys, or an instance of `KeyStack` which will be used to sign
+     * cookies read and set by the application to avoid tampering with the
+     * cookies. */
+    get keys() {
+        return __classPrivateFieldGet(this, _Application_keys, "f");
+    }
+    set keys(keys) {
+        if (!keys) {
+            __classPrivateFieldSet(this, _Application_keys, undefined, "f");
+            return;
+        }
+        else if (Array.isArray(keys)) {
+            __classPrivateFieldSet(this, _Application_keys, new KeyStack(keys), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Application_keys, keys, "f");
+        }
+    }
+    constructor(options = {}) {
+        super();
+        _Application_instances.add(this);
+        _Application_composedMiddleware.set(this, void 0);
+        _Application_contextOptions.set(this, void 0);
+        _Application_contextState.set(this, void 0);
+        _Application_keys.set(this, void 0);
+        _Application_middleware.set(this, []);
+        _Application_serverConstructor.set(this, void 0);
+        /** If `true`, proxy headers will be trusted when processing requests.  This
+         * defaults to `false`. */
+        Object.defineProperty(this, "proxy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Generic state of the application, which can be specified by passing the
+         * generic argument when constructing:
+         *
+         *       const app = new Application<{ foo: string }>();
+         *
+         * Or can be contextually inferred based on setting an initial state object:
+         *
+         *       const app = new Application({ state: { foo: "bar" } });
+         *
+         * When a new context is created, the application's state is cloned and the
+         * state is unique to that request/response.  Changes can be made to the
+         * application state that will be shared with all contexts.
+         */
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** A method that is compatible with the Cloudflare Worker
+         * [Fetch Handler](https://developers.cloudflare.com/workers/runtime-apis/handlers/fetch/)
+         * and can be exported to handle Cloudflare Worker fetch requests.
+         *
+         * # Example
+         *
+         * ```ts
+         * import { Application } from "@oak/oak";
+         *
+         * const app = new Application();
+         * app.use((ctx) => {
+         *   ctx.response.body = "hello world!";
+         * });
+         *
+         * export default { fetch: app.fetch };
+         * ```
+         */
+        Object.defineProperty(this, "fetch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (request, _env, _ctx) => {
+                if (!__classPrivateFieldGet(this, _Application_middleware, "f").length) {
+                    throw new TypeError("There is no middleware to process requests.");
+                }
+                if (!NativeRequestCtor) {
+                    const { NativeRequest } = await import("./http_server_native_request.js");
+                    NativeRequestCtor = NativeRequest;
+                }
+                let remoteAddr;
+                const hostname = request.headers.get("CF-Connecting-IP") ?? undefined;
+                if (hostname) {
+                    remoteAddr = { hostname, port: 0, transport: "tcp" };
+                }
+                const contextRequest = new NativeRequestCtor(request, { remoteAddr });
+                const context = new Context(this, contextRequest, __classPrivateFieldGet(this, _Application_instances, "m", _Application_getContextState).call(this), __classPrivateFieldGet(this, _Application_contextOptions, "f"));
+                try {
+                    await __classPrivateFieldGet(this, _Application_instances, "m", _Application_getComposed).call(this)(context);
+                    const response = await context.response.toDomResponse();
+                    context.response.destroy(false);
+                    return response;
+                }
+                catch (err) {
+                    __classPrivateFieldGet(this, _Application_instances, "m", _Application_handleError).call(this, context, err);
+                    throw err;
+                }
+            }
+        });
+        /** Handle an individual server request, returning the server response.  This
+         * is similar to `.listen()`, but opening the connection and retrieving
+         * requests are not the responsibility of the application.  If the generated
+         * context gets set to not to respond, then the method resolves with
+         * `undefined`, otherwise it resolves with a standard {@linkcode Response}. */
+        Object.defineProperty(this, "handle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (async (request, secureOrAddr, secure = false) => {
+                if (!__classPrivateFieldGet(this, _Application_middleware, "f").length) {
+                    throw new TypeError("There is no middleware to process requests.");
+                }
+                assert(isNetAddr(secureOrAddr) || typeof secureOrAddr === "undefined");
+                if (!NativeRequestCtor) {
+                    const { NativeRequest } = await import("./http_server_native_request.js");
+                    NativeRequestCtor = NativeRequest;
+                }
+                const contextRequest = new NativeRequestCtor(request, {
+                    remoteAddr: secureOrAddr,
+                });
+                const context = new Context(this, contextRequest, __classPrivateFieldGet(this, _Application_instances, "m", _Application_getContextState).call(this), { secure, ...__classPrivateFieldGet(this, _Application_contextOptions, "f") });
+                try {
+                    await __classPrivateFieldGet(this, _Application_instances, "m", _Application_getComposed).call(this)(context);
+                }
+                catch (err) {
+                    __classPrivateFieldGet(this, _Application_instances, "m", _Application_handleError).call(this, context, err);
+                }
+                if (context.respond === false) {
+                    context.response.destroy();
+                    return;
+                }
+                try {
+                    const response = await context.response.toDomResponse();
+                    context.response.destroy(false);
+                    return response;
+                }
+                catch (err) {
+                    __classPrivateFieldGet(this, _Application_instances, "m", _Application_handleError).call(this, context, err);
+                    throw err;
+                }
+            })
+        });
+        const { state, keys, proxy, serverConstructor, contextState = "clone", logErrors = true, ...contextOptions } = options;
+        this.proxy = proxy ?? false;
+        this.keys = keys;
+        this.state = state ?? {};
+        __classPrivateFieldSet(this, _Application_serverConstructor, serverConstructor, "f");
+        __classPrivateFieldSet(this, _Application_contextOptions, contextOptions, "f");
+        __classPrivateFieldSet(this, _Application_contextState, contextState, "f");
+        if (logErrors) {
+            this.addEventListener("error", logErrorListener);
+        }
+    }
+    /** Add an event listener for an event.  Currently valid event types are
+     * `"error"` and `"listen"`. */
+    addEventListener(type, listener, options) {
+        super.addEventListener(type, listener, options);
+    }
+    async listen(options = { port: 0 }) {
+        if (!__classPrivateFieldGet(this, _Application_middleware, "f").length) {
+            throw new TypeError("There is no middleware to process requests.");
+        }
+        for (const middleware of __classPrivateFieldGet(this, _Application_middleware, "f")) {
+            if (isMiddlewareObject(middleware) && middleware.init) {
+                await middleware.init();
+            }
+        }
+        if (typeof options === "string") {
+            const match = ADDR_REGEXP.exec(options);
+            if (!match) {
+                throw TypeError(`Invalid address passed: "${options}"`);
+            }
+            const [, hostname, portStr] = match;
+            options = { hostname, port: parseInt(portStr, 10) };
+        }
+        options = Object.assign({ port: 0 }, options);
+        if (!__classPrivateFieldGet(this, _Application_serverConstructor, "f")) {
+            if (!DefaultServerCtor) {
+                const { Server } = await (isBun()
+                    ? import("./http_server_bun.js")
+                    : isNode()
+                        ? import("./http_server_node.js")
+                        : import("./http_server_native.js"));
+                DefaultServerCtor = Server;
+            }
+            __classPrivateFieldSet(this, _Application_serverConstructor, DefaultServerCtor, "f");
+        }
+        const server = new (__classPrivateFieldGet(this, _Application_serverConstructor, "f"))(this, options);
+        const state = {
+            closed: false,
+            closing: false,
+            handling: new Set(),
+            server,
+        };
+        const { signal } = options;
+        if (signal) {
+            signal.addEventListener("abort", () => {
+                if (!state.handling.size) {
+                    state.closed = true;
+                    this.dispatchEvent(new ApplicationCloseEvent({}));
+                }
+                state.closing = true;
+            }, { once: true });
+        }
+        const { secure = false } = options;
+        const serverType = __classPrivateFieldGet(this, _Application_serverConstructor, "f").type ?? "custom";
+        const listener = await server.listen();
+        const { hostname, port } = listener.addr;
+        this.dispatchEvent(new ApplicationListenEvent({
+            hostname,
+            listener,
+            port,
+            secure,
+            serverType,
+        }));
+        try {
+            for await (const request of server) {
+                __classPrivateFieldGet(this, _Application_instances, "m", _Application_handleRequest).call(this, request, secure, state);
+            }
+            await Promise.all(state.handling);
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : "Application Error";
+            this.dispatchEvent(new ApplicationErrorEvent({ message, error }));
+        }
+    }
+    use(...middleware) {
+        __classPrivateFieldGet(this, _Application_middleware, "f").push(...middleware);
+        __classPrivateFieldSet(this, _Application_composedMiddleware, undefined, "f");
+        // deno-lint-ignore no-explicit-any
+        return this;
+    }
+    [(_Application_composedMiddleware = new WeakMap(), _Application_contextOptions = new WeakMap(), _Application_contextState = new WeakMap(), _Application_keys = new WeakMap(), _Application_middleware = new WeakMap(), _Application_serverConstructor = new WeakMap(), _Application_instances = new WeakSet(), _Application_getComposed = function _Application_getComposed() {
+        if (!__classPrivateFieldGet(this, _Application_composedMiddleware, "f")) {
+            __classPrivateFieldSet(this, _Application_composedMiddleware, compose(__classPrivateFieldGet(this, _Application_middleware, "f")), "f");
+        }
+        return __classPrivateFieldGet(this, _Application_composedMiddleware, "f");
+    }, _Application_getContextState = function _Application_getContextState() {
+        switch (__classPrivateFieldGet(this, _Application_contextState, "f")) {
+            case "alias":
+                return this.state;
+            case "clone":
+                return cloneState(this.state);
+            case "empty":
+                return {};
+            case "prototype":
+                return Object.create(this.state);
+        }
+    }, _Application_handleError = function _Application_handleError(context, error) {
+        if (!(error instanceof Error)) {
+            error = new Error(`non-error thrown: ${JSON.stringify(error)}`);
+        }
+        const { message } = error;
+        if (!context.response.writable) {
+            this.dispatchEvent(new ApplicationErrorEvent({ context, message, error }));
+            return;
+        }
+        for (const key of [...context.response.headers.keys()]) {
+            context.response.headers.delete(key);
+        }
+        if (error.headers && error.headers instanceof Headers) {
+            for (const [key, value] of error.headers) {
+                context.response.headers.set(key, value);
+            }
+        }
+        context.response.type = "text";
+        const status = context.response.status =
+            dntShim.dntGlobalThis.Deno && dntShim.Deno.errors && error instanceof dntShim.Deno.errors.NotFound
+                ? 404
+                : error.status && typeof error.status === "number"
+                    ? error.status
+                    : 500;
+        context.response.body = error.expose ? error.message : STATUS_TEXT[status];
+        this.dispatchEvent(new ApplicationErrorEvent({ context, message, error }));
+    }, _Application_handleRequest = 
+    /** Processing registered middleware on each request. */
+    async function _Application_handleRequest(request, secure, state) {
+        let context;
+        try {
+            context = new Context(this, request, __classPrivateFieldGet(this, _Application_instances, "m", _Application_getContextState).call(this), { secure, ...__classPrivateFieldGet(this, _Application_contextOptions, "f") });
+        }
+        catch (e) {
+            const error = e instanceof Error
+                ? e
+                : new Error(`non-error thrown: ${JSON.stringify(e)}`);
+            const { message } = error;
+            this.dispatchEvent(new ApplicationErrorEvent({ message, error }));
+            return;
+        }
+        assert(context, "Context was not created.");
+        const { promise, resolve } = createPromiseWithResolvers();
+        state.handling.add(promise);
+        if (!state.closing && !state.closed) {
+            try {
+                await __classPrivateFieldGet(this, _Application_instances, "m", _Application_getComposed).call(this)(context);
+            }
+            catch (err) {
+                __classPrivateFieldGet(this, _Application_instances, "m", _Application_handleError).call(this, context, err);
+            }
+        }
+        if (context.respond === false) {
+            context.response.destroy();
+            resolve();
+            state.handling.delete(promise);
+            return;
+        }
+        let closeResources = true;
+        let response;
+        try {
+            closeResources = false;
+            response = await context.response.toDomResponse();
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _Application_instances, "m", _Application_handleError).call(this, context, err);
+            response = await context.response.toDomResponse();
+        }
+        assert(response);
+        try {
+            await request.respond(response);
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _Application_instances, "m", _Application_handleError).call(this, context, err);
+        }
+        finally {
+            context.response.destroy(closeResources);
+            resolve();
+            state.handling.delete(promise);
+            if (state.closing) {
+                await state.server.close();
+                if (!state.closed) {
+                    this.dispatchEvent(new ApplicationCloseEvent({}));
+                }
+                state.closed = true;
+            }
+        }
+    }, Symbol.for("Deno.customInspect"))](inspect) {
+        const { keys, proxy, state } = this;
+        return `${this.constructor.name} ${inspect({ "#middleware": __classPrivateFieldGet(this, _Application_middleware, "f"), keys, proxy, state })}`;
+    }
+    [Symbol.for("nodejs.util.inspect.custom")](depth, 
+    // deno-lint-ignore no-explicit-any
+    options, inspect) {
+        if (depth < 0) {
+            return options.stylize(`[${this.constructor.name}]`, "special");
+        }
+        const newOptions = Object.assign({}, options, {
+            depth: options.depth === null ? null : options.depth - 1,
+        });
+        const { keys, proxy, state } = this;
+        return `${options.stylize(this.constructor.name, "special")} ${inspect({ "#middleware": __classPrivateFieldGet(this, _Application_middleware, "f"), keys, proxy, state }, newOptions)}`;
+    }
+}

package/esm/deps/deno.land/x/oak@v17.1.4/body.d.ts

@@ -0,0 +1,71 @@
+import type { ServerRequest } from "./types.js";
+type JsonReviver = (key: string, value: unknown) => unknown;
+export type BodyType = "binary" | "form" | "form-data" | "json" | "text" | "unknown";
+/** An object which encapsulates information around a request body. */
+export declare class Body {
+    #private;
+    constructor(serverRequest: Pick<ServerRequest, "request" | "headers" | "getBody">, reviver?: JsonReviver);
+    /** Is `true` if the request might have a body, otherwise `false`.
+     *
+     * **WARNING** this is an unreliable API. In HTTP/2 in many situations you
+     * cannot determine if a request has a body or not unless you attempt to read
+     * the body, due to the streaming nature of HTTP/2. As of Deno 1.16.1, for
+     * HTTP/1.1, Deno also reflects that behavior.  The only reliable way to
+     * determine if a request has a body or not is to attempt to read the body.
+     */
+    get has(): boolean;
+    /** Exposes the "raw" `ReadableStream` of the body. */
+    get stream(): ReadableStream<Uint8Array> | null;
+    /** Returns `true` if the body has been consumed yet, otherwise `false`. */
+    get used(): boolean;
+    /** Return the body to be reused as BodyInit. */
+    init(): Promise<BodyInit | null>;
+    /** Reads a body to the end and resolves with the value as an
+     * {@linkcode ArrayBuffer} */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /** Reads a body to the end and resolves with the value as a
+     * {@linkcode Blob}. */
+    blob(): Promise<Blob>;
+    /** Reads a body as a URL encoded form, resolving the value as
+     * {@linkcode URLSearchParams}. */
+    form(): Promise<URLSearchParams>;
+    /** Reads a body to the end attempting to parse the body as a set of
+     * {@linkcode FormData}. */
+    formData(): Promise<FormData>;
+    /** Reads a body to the end attempting to parse the body as a JSON value.
+     *
+     * If a JSON reviver has been assigned, it will be used to parse the body.
+     */
+    json(): Promise<any>;
+    /** Reads the body to the end resolving with a string. */
+    text(): Promise<string>;
+    /** Attempts to determine what type of the body is to help determine how best
+     * to attempt to decode the body. This performs analysis on the supplied
+     * `Content-Type` header of the request.
+     *
+     * **Note** these are not authoritative and should only be used as guidance.
+     *
+     * There is the ability to provide custom types when attempting to discern
+     * the type. Custom types are provided in the format of an object where the
+     * key is on of {@linkcode BodyType} and the value is an array of media types
+     * to attempt to match. Values supplied will be additive to known media types.
+     *
+     * The returned value is one of the following:
+     *
+     * - `"binary"` - The body appears to be binary data and should be consumed as
+     *   an array buffer, readable stream or blob.
+     * - `"form"` - The value appears to be an URL encoded form and should be
+     *   consumed as a form (`URLSearchParams`).
+     * - `"form-data"` - The value appears to be multipart form data and should be
+     *   consumed as form data.
+     * - `"json"` - The value appears to be JSON data and should be consumed as
+     *   decoded JSON.
+     * - `"text"` - The value appears to be text data and should be consumed as
+     *   text.
+     * - `"unknown"` - Either there is no body or the body type could not be
+     *   determined.
+     */
+    type(customMediaTypes?: Partial<Record<BodyType, string[]>>): BodyType;
+}
+export {};
+//# sourceMappingURL=body.d.ts.map

package/esm/deps/deno.land/x/oak@v17.1.4/body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/x/oak@v17.1.4/body.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,KAAK,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;AAE5D,MAAM,MAAM,QAAQ,GAChB,QAAQ,GACR,MAAM,GACN,WAAW,GACX,MAAM,GACN,MAAM,GACN,SAAS,CAAC;AAwBd,sEAAsE;AACtE,qBAAa,IAAI;;gBAWb,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC,EACrE,OAAO,CAAC,EAAE,WAAW;IAWvB;;;;;;;OAOG;IACH,IAAI,GAAG,IAAI,OAAO,CAEjB;IAED,sDAAsD;IACtD,IAAI,MAAM,IAAI,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAE9C;IAED,2EAA2E;IAC3E,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,gDAAgD;IAC1C,IAAI,IAAI,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAOtC;iCAC6B;IACvB,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAczC;2BACuB;IACvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBrB;sCACkC;IAC5B,IAAI,IAAI,OAAO,CAAC,eAAe,CAAC;IAKtC;+BAC2B;IAC3B,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;IAoB7B;;;OAGG;IAEG,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;IAW1B,yDAAyD;IACnD,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAc7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,IAAI,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,GAAG,QAAQ;CAgDvE"}