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

package/esm/deps/jsr.io/@oak/commons/1.0.0/http_errors.js

@@ -0,0 +1,233 @@
+// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
+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 _HttpError_expose;
+/**
+ * A collection of HTTP errors and utilities.
+ *
+ * The export {@linkcode errors} contains an individual class that extends
+ * {@linkcode HttpError} which makes handling HTTP errors in a structured way.
+ *
+ * The function {@linkcode createHttpError} provides a way to create instances
+ * of errors in a factory pattern.
+ *
+ * The function {@linkcode isHttpError} is a type guard that will narrow a value
+ * to an `HttpError` instance.
+ *
+ * @example
+ * ```ts
+ * import { errors, isHttpError } from "jsr:@oak/commons/http_errors";
+ *
+ * try {
+ *   throw new errors.NotFound();
+ * } catch (e) {
+ *   if (isHttpError(e)) {
+ *     const response = new Response(e.message, { status: e.status });
+ *   } else {
+ *     throw e;
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { createHttpError } from "jsr:@oak/commons/http_errors";
+ * import { Status } from "jsr:@oak/commons/status";
+ *
+ * try {
+ *   throw createHttpError(
+ *     Status.BadRequest,
+ *     "The request was bad.",
+ *     { expose: false }
+ *   );
+ * } catch (e) {
+ *   // handle errors
+ * }
+ * ```
+ *
+ * @module
+ */
+import { accepts } from "../../../@std/http/1.0.13/negotiation.js";
+import { contentType } from "../../../@std/media-types/1.1.0/content_type.js";
+import { isClientErrorStatus, Status, STATUS_TEXT, } from "./status.js";
+const ERROR_STATUS_MAP = {
+    "BadRequest": 400,
+    "Unauthorized": 401,
+    "PaymentRequired": 402,
+    "Forbidden": 403,
+    "NotFound": 404,
+    "MethodNotAllowed": 405,
+    "NotAcceptable": 406,
+    "ProxyAuthRequired": 407,
+    "RequestTimeout": 408,
+    "Conflict": 409,
+    "Gone": 410,
+    "LengthRequired": 411,
+    "PreconditionFailed": 412,
+    "RequestEntityTooLarge": 413,
+    "RequestURITooLong": 414,
+    "UnsupportedMediaType": 415,
+    "RequestedRangeNotSatisfiable": 416,
+    "ExpectationFailed": 417,
+    "Teapot": 418,
+    "MisdirectedRequest": 421,
+    "UnprocessableEntity": 422,
+    "Locked": 423,
+    "FailedDependency": 424,
+    "UpgradeRequired": 426,
+    "PreconditionRequired": 428,
+    "TooManyRequests": 429,
+    "RequestHeaderFieldsTooLarge": 431,
+    "UnavailableForLegalReasons": 451,
+    "InternalServerError": 500,
+    "NotImplemented": 501,
+    "BadGateway": 502,
+    "ServiceUnavailable": 503,
+    "GatewayTimeout": 504,
+    "HTTPVersionNotSupported": 505,
+    "VariantAlsoNegotiates": 506,
+    "InsufficientStorage": 507,
+    "LoopDetected": 508,
+    "NotExtended": 510,
+    "NetworkAuthenticationRequired": 511,
+};
+/**
+ * The base class that all derivative HTTP extend, providing a `status` and an
+ * `expose` property.
+ */
+export class HttpError extends Error {
+    constructor(message = "Http Error", options) {
+        super(message, options);
+        _HttpError_expose.set(this, void 0);
+        __classPrivateFieldSet(this, _HttpError_expose, options?.expose === undefined
+            ? isClientErrorStatus(this.status)
+            : options.expose, "f");
+    }
+    /** A flag to indicate if the internals of the error, like the stack, should
+     * be exposed to a client, or if they are "private" and should not be leaked.
+     * By default, all client errors are `true` and all server errors are
+     * `false`. */
+    get expose() {
+        return __classPrivateFieldGet(this, _HttpError_expose, "f");
+    }
+    /** The error status that is set on the error. */
+    get status() {
+        return Status.InternalServerError;
+    }
+    /**
+     * Format the error as a {@linkcode Response} which can be sent to a client.
+     */
+    asResponse(options = {}) {
+        const { prefer = "json", request, headers } = options;
+        const acceptsContent = request
+            ? prefer === "json"
+                ? accepts(request, "application/json", "text/html")
+                : accepts(request, "text/html", "application/json")
+            : prefer === "json"
+                ? "application/json"
+                : "text/html";
+        switch (acceptsContent) {
+            case "application/json":
+                return Response.json({
+                    status: this.status,
+                    statusText: STATUS_TEXT[this.status],
+                    message: this.message,
+                    stack: __classPrivateFieldGet(this, _HttpError_expose, "f") ? this.stack : undefined,
+                }, {
+                    status: this.status,
+                    statusText: STATUS_TEXT[this.status],
+                    headers,
+                });
+            case "text/html": {
+                const res = new Response(`<!DOCTYPE html><html>
+        <head>
+          <title>${STATUS_TEXT[this.status]} - ${this.status}</title>
+        </head>
+        <body>
+          <h1>${STATUS_TEXT[this.status]} - ${this.status}</h1>
+          <h2>${this.message}</h2>
+          ${__classPrivateFieldGet(this, _HttpError_expose, "f") && this.stack
+                    ? `<h3>Stack trace:</h3><pre>${this.stack}</pre>`
+                    : ""}
+        </body>
+      </html>`, {
+                    status: this.status,
+                    statusText: STATUS_TEXT[this.status],
+                    headers,
+                });
+                res.headers.set("content-type", contentType("html"));
+                return res;
+            }
+        }
+        const res = new Response(`${STATUS_TEXT[this.status]} - ${this.status}\n${this.message}\n\n${__classPrivateFieldGet(this, _HttpError_expose, "f") ? this.stack : ""}`, {
+            status: this.status,
+            statusText: STATUS_TEXT[this.status],
+            headers,
+        });
+        res.headers.set("content-type", contentType("txt"));
+        return res;
+    }
+}
+_HttpError_expose = new WeakMap();
+function createHttpErrorConstructor(status) {
+    const name = `${Status[status]}Error`;
+    const ErrorCtor = class extends HttpError {
+        constructor(message = STATUS_TEXT[status], options) {
+            super(message, options);
+            Object.defineProperty(this, "name", {
+                configurable: true,
+                enumerable: false,
+                value: name,
+                writable: true,
+            });
+        }
+        get status() {
+            return status;
+        }
+    };
+    return ErrorCtor;
+}
+/**
+ * A namespace that contains each error constructor. Each error extends
+ * `HTTPError` and provides `.status` and `.expose` properties, where the
+ * `.status` will be an error `Status` value and `.expose` indicates if
+ * information, like a stack trace, should be shared in the response.
+ *
+ * By default, `.expose` is set to false in server errors, and true for client
+ * errors.
+ *
+ * @example
+ * ```ts
+ * import { errors } from "jsr:@oak/commons/http_errors";
+ *
+ * throw new errors.InternalServerError("Ooops!");
+ * ```
+ */
+export const errors = {};
+for (const [key, value] of Object.entries(ERROR_STATUS_MAP)) {
+    errors[key] = createHttpErrorConstructor(value);
+}
+/**
+ * A factory function which provides a way to create errors. It takes up to 3
+ * arguments, the error `Status`, an message, which defaults to the status text
+ * and error options, which includes the `expose` property to set the `.expose`
+ * value on the error.
+ */
+export function createHttpError(status = Status.InternalServerError, message, options) {
+    return new errors[Status[status]](message, options);
+}
+/**
+ * A type guard that determines if the value is an HttpError or not.
+ */
+export function isHttpError(value) {
+    return value instanceof HttpError;
+}

package/esm/deps/jsr.io/@oak/commons/1.0.0/keystack.d.ts

@@ -0,0 +1,56 @@
+/** Types of data that can be signed cryptographically. */
+export type Data = string | number[] | ArrayBuffer | Uint8Array;
+/** Types of keys that can be used to sign data. */
+export type Key = string | number[] | ArrayBuffer | Uint8Array;
+/**
+ * A cryptographic key chain which allows signing of data to prevent tampering,
+ * but also allows for easy key rotation without needing to re-sign the data.
+ *
+ * Data is signed as SHA256 HMAC.
+ *
+ * This was inspired by {@link https://github.com/crypto-utils/keygrip/ | keygrip}.
+ *
+ * @example
+ * ```ts
+ * import { KeyStack } from "@oak/commons/keystack";
+ *
+ * const keyStack = new KeyStack(["hello", "world"]);
+ * const digest = await keyStack.sign("some data");
+ *
+ * const rotatedStack = new KeyStack(["deno", "says", "hello", "world"]);
+ * await rotatedStack.verify("some data", digest); // true
+ * ```
+ */
+export declare class KeyStack {
+    #private;
+    /** Number of keys */
+    get length(): number;
+    /**
+     * A class which accepts an array of keys that are used to sign and verify
+     * data and allows easy key rotation without invalidation of previously signed
+     * data.
+     *
+     * @param keys An iterable of keys, of which the index 0 will be used to sign
+     *             data, but verification can happen against any key.
+     */
+    constructor(keys: Iterable<Key>);
+    /**
+     * Take `data` and return a SHA256 HMAC digest that uses the current 0 index
+     * of the `keys` passed to the constructor.  This digest is in the form of a
+     * URL safe base64 encoded string.
+     */
+    sign(data: Data): Promise<string>;
+    /**
+     * Given `data` and a `digest`, verify that one of the `keys` provided the
+     * constructor was used to generate the `digest`.  Returns `true` if one of
+     * the keys was used, otherwise `false`.
+     */
+    verify(data: Data, digest: string): Promise<boolean>;
+    /**
+     * Given `data` and a `digest`, return the current index of the key in the
+     * `keys` passed the constructor that was used to generate the digest.  If no
+     * key can be found, the method returns `-1`.
+     */
+    indexOf(data: Data, digest: string): Promise<number>;
+}
+//# sourceMappingURL=keystack.d.ts.map

package/esm/deps/jsr.io/@oak/commons/1.0.0/keystack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystack.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/keystack.ts"],"names":[],"mappings":"AAYA,0DAA0D;AAC1D,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,WAAW,GAAG,UAAU,CAAC;AAEhE,mDAAmD;AACnD,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,WAAW,GAAG,UAAU,CAAC;AAqD/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,QAAQ;;IAWnB,qBAAqB;IACrB,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;OAOG;gBACS,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC;IAQ/B;;;;OAIG;IACG,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvC;;;;OAIG;IACG,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI1D;;;;OAIG;IACG,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CA2C3D"}

package/esm/deps/jsr.io/@oak/commons/1.0.0/keystack.js

@@ -0,0 +1,165 @@
+// Copyright 2018-2024 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 _KeyStack_instances, _KeyStack_cryptoKeys, _KeyStack_keys, _KeyStack_toCryptoKey;
+/**
+ * Provides the {@linkcode KeyStack} class which implements a key ring interface
+ * for managing rotatable keys.
+ *
+ * @module
+ */
+import { timingSafeEqual } from "../../../@std/crypto/1.0.4/timing_safe_equal.js";
+import { encodeBase64Url } from "../../../@std/encoding/1.0.7/base64url.js";
+const encoder = new TextEncoder();
+function importKey(key) {
+    if (typeof key === "string") {
+        key = encoder.encode(key);
+    }
+    else if (Array.isArray(key)) {
+        key = new Uint8Array(key);
+    }
+    return crypto.subtle.importKey("raw", key, {
+        name: "HMAC",
+        hash: { name: "SHA-256" },
+    }, true, ["sign", "verify"]);
+}
+function sign(data, key) {
+    if (typeof data === "string") {
+        data = encoder.encode(data);
+    }
+    else if (Array.isArray(data)) {
+        data = Uint8Array.from(data);
+    }
+    return crypto.subtle.sign("HMAC", key, data);
+}
+/**
+ * Compare two strings, Uint8Arrays, ArrayBuffers, or arrays of numbers in a
+ * way that avoids timing based attacks on the comparisons on the values.
+ *
+ * The function will return `true` if the values match, or `false`, if they
+ * do not match.
+ *
+ * This was inspired by https://github.com/suryagh/tsscmp which provides a
+ * timing safe string comparison to avoid timing attacks as described in
+ * https://codahale.com/a-lesson-in-timing-attacks/.
+ */
+async function compare(a, b) {
+    const key = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(key);
+    const cryptoKey = await importKey(key);
+    const [ah, bh] = await Promise.all([
+        sign(a, cryptoKey),
+        sign(b, cryptoKey),
+    ]);
+    return timingSafeEqual(ah, bh);
+}
+/**
+ * A cryptographic key chain which allows signing of data to prevent tampering,
+ * but also allows for easy key rotation without needing to re-sign the data.
+ *
+ * Data is signed as SHA256 HMAC.
+ *
+ * This was inspired by {@link https://github.com/crypto-utils/keygrip/ | keygrip}.
+ *
+ * @example
+ * ```ts
+ * import { KeyStack } from "@oak/commons/keystack";
+ *
+ * const keyStack = new KeyStack(["hello", "world"]);
+ * const digest = await keyStack.sign("some data");
+ *
+ * const rotatedStack = new KeyStack(["deno", "says", "hello", "world"]);
+ * await rotatedStack.verify("some data", digest); // true
+ * ```
+ */
+export class KeyStack {
+    /** Number of keys */
+    get length() {
+        return __classPrivateFieldGet(this, _KeyStack_keys, "f").length;
+    }
+    /**
+     * A class which accepts an array of keys that are used to sign and verify
+     * data and allows easy key rotation without invalidation of previously signed
+     * data.
+     *
+     * @param keys An iterable of keys, of which the index 0 will be used to sign
+     *             data, but verification can happen against any key.
+     */
+    constructor(keys) {
+        _KeyStack_instances.add(this);
+        _KeyStack_cryptoKeys.set(this, new Map());
+        _KeyStack_keys.set(this, void 0);
+        const values = Array.isArray(keys) ? keys : [...keys];
+        if (!(values.length)) {
+            throw new TypeError("keys must contain at least one value");
+        }
+        __classPrivateFieldSet(this, _KeyStack_keys, values, "f");
+    }
+    /**
+     * Take `data` and return a SHA256 HMAC digest that uses the current 0 index
+     * of the `keys` passed to the constructor.  This digest is in the form of a
+     * URL safe base64 encoded string.
+     */
+    async sign(data) {
+        const key = await __classPrivateFieldGet(this, _KeyStack_instances, "m", _KeyStack_toCryptoKey).call(this, __classPrivateFieldGet(this, _KeyStack_keys, "f")[0]);
+        return encodeBase64Url(await sign(data, key));
+    }
+    /**
+     * Given `data` and a `digest`, verify that one of the `keys` provided the
+     * constructor was used to generate the `digest`.  Returns `true` if one of
+     * the keys was used, otherwise `false`.
+     */
+    async verify(data, digest) {
+        return (await this.indexOf(data, digest)) > -1;
+    }
+    /**
+     * Given `data` and a `digest`, return the current index of the key in the
+     * `keys` passed the constructor that was used to generate the digest.  If no
+     * key can be found, the method returns `-1`.
+     */
+    async indexOf(data, digest) {
+        for (let i = 0; i < __classPrivateFieldGet(this, _KeyStack_keys, "f").length; i++) {
+            const key = __classPrivateFieldGet(this, _KeyStack_keys, "f")[i];
+            const cryptoKey = await __classPrivateFieldGet(this, _KeyStack_instances, "m", _KeyStack_toCryptoKey).call(this, key);
+            if (await compare(digest, encodeBase64Url(await sign(data, cryptoKey)))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /** Custom output for {@linkcode Deno.inspect}. */
+    [(_KeyStack_cryptoKeys = new WeakMap(), _KeyStack_keys = new WeakMap(), _KeyStack_instances = new WeakSet(), _KeyStack_toCryptoKey = async function _KeyStack_toCryptoKey(key) {
+        if (!__classPrivateFieldGet(this, _KeyStack_cryptoKeys, "f").has(key)) {
+            __classPrivateFieldGet(this, _KeyStack_cryptoKeys, "f").set(key, await importKey(key));
+        }
+        return __classPrivateFieldGet(this, _KeyStack_cryptoKeys, "f").get(key);
+    }, Symbol.for("Deno.customInspect"))](inspect) {
+        const { length } = this;
+        return `${this.constructor.name} ${inspect({ length })}`;
+    }
+    /**
+     * Custom output for Node's
+     * {@linkcode https://nodejs.org/api/util.html#utilinspectobject-options|util.inspect}.
+     */
+    [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 { length } = this;
+        return `${options.stylize(this.constructor.name, "special")} ${inspect({ length }, newOptions)}`;
+    }
+}

package/esm/deps/jsr.io/@oak/commons/1.0.0/media_types.d.ts

@@ -0,0 +1,56 @@
+/** A class which encapsulates the information in a media type, allowing
+ * inspecting of modifying individual parts of the media type. */
+export declare class MediaType {
+    #private;
+    /** Create an instance of {@linkcode MediaType} by providing the components
+     * of `type`, `subtype` and optionally a `suffix`. */
+    constructor(type: string, subtype: string, suffix?: string);
+    /** The subtype of the media type. */
+    set subtype(value: string);
+    /** The subtype of the media type. */
+    get subtype(): string;
+    /** The optional suffix of the media type. */
+    set suffix(value: string | undefined);
+    /** The optional suffix of the media type. */
+    get suffix(): string | undefined;
+    /** The type of the media type. */
+    set type(value: string);
+    /** The type of the media type. */
+    get type(): string;
+    /** Return the parsed media type in its valid string format. */
+    toString(): string;
+    /** Take a string and attempt to parse it into a {@linkcode MediaType}
+     * object. */
+    static parse(value: string): MediaType;
+}
+/** Determines if the provided media type matches one of the supplied media
+ * types. If there is a match, the matched media type is returned, otherwise
+ * `undefined` is returned.
+ *
+ * Each type in the media types array can be one of the following:
+ *
+ * - A file extension name such as `json`. This name will be returned if
+ *   matched.
+ * - A media type such as `application/json`.
+ * - A media type with a wildcard such as `*​/*` or `*​/json` or `application/*`.
+ *   The full media type will be returned if matched.
+ * - A suffix such as `+json`. This can be combined with a wildcard such as
+ *   `*​/vnd+json` or `application/*+json`. The full mime type will be returned
+ *   if matched.
+ * - Special cases of `urlencoded` and `multipart` which get normalized to
+ *   `application/x-www-form-urlencoded` and `multipart/*` respectively.
+ */
+export declare function matches(value: string, mediaTypes: string[]): string | undefined;
+/**
+ * Convert a type, subtype and optional suffix of a media type into its valid
+ * string form.
+ */
+export declare function format(value: {
+    type: string;
+    subtype: string;
+    suffix?: string;
+}): string;
+/** Parses a media type into a {@linkcode MediaType} object which provides
+ * parts of the media type as individual properties. */
+export declare function parse(value: string): MediaType;
+//# sourceMappingURL=media_types.d.ts.map

package/esm/deps/jsr.io/@oak/commons/1.0.0/media_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/media_types.ts"],"names":[],"mappings":"AAwFA;iEACiE;AACjE,qBAAa,SAAS;;IAKpB;yDACqD;gBACzC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAQ1D,qCAAqC;IACrC,IAAI,OAAO,CAAC,KAAK,EAAE,MAAM,EAKxB;IAED,qCAAqC;IACrC,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,6CAA6C;IAC7C,IAAI,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAKnC;IAED,6CAA6C;IAC7C,IAAI,MAAM,IAAI,MAAM,GAAG,SAAS,CAE/B;IAED,kCAAkC;IAClC,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAKrB;IAED,kCAAkC;IAClC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,+DAA+D;IAC/D,QAAQ,IAAI,MAAM;IAMlB;iBACa;IACb,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;CAkBvC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAAE,GACnB,MAAM,GAAG,SAAS,CAoBpB;AAED;;;GAGG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACxD,MAAM,CAKR;AAED;uDACuD;AACvD,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAE9C"}