@telorun/cel 0.0.0-stage → 0.108.0

package/dist/backend-runtime.js

@@ -0,0 +1,425 @@
+/**
+ * What a backend does at each kind of site — once, for both of them.
+ *
+ * `runtime-library.ts` holds what every operator and standard function **does**. This
+ * holds everything *around* a call: admitting a host value, reading a member in every
+ * form, taking a bool operand, reading a name or a dotted chain, and the per-call-site
+ * overload dispatch with its bounded cache. None of it is a tree walk and none of it is an
+ * operator, which is exactly why it cannot live in a backend: the closure backend compiles
+ * a tree to closures and the emitter compiles the same tree to JavaScript source, and both
+ * call *these* functions. A second copy of the dispatch rule or the member-read rule is a
+ * second set of answers, and the whole point of two backends over one runtime is that
+ * there is one answer per operation.
+ *
+ * So the emitter emits a call to `readThrough` and never a bare `obj.name`; it emits a
+ * `CallSite` per call and never its own overload search; and a thenable is refused at the
+ * same doors on both backends because the doors are here.
+ */
+import { activationHolds } from "./activation.js";
+import { BoundedCache } from "./bounded-cache.js";
+import { BOOL, BYTES, DOUBLE, DURATION, DYN, INT, listOf, mapOf, NULL, optionalOf, STRING, TIMESTAMP, TYPE, UINT, } from "./cel-type.js";
+import { asyncValueRefused, CEL_VALUE_TYPE, celError, celNone, celSome, celTypeNameOf, isCelError, isCelOptional, } from "./cel-value.js";
+import { celHas, celLookup, celRead, lookupAbsence, lookupError } from "./member-read.js";
+import { implementationOf } from "./runtime-library.js";
+/** A compile-time refusal: a tree neither backend can compile at all. */
+export class CelCompileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CelCompileError";
+    }
+}
+/** How many distinct argument-type combinations one call site remembers. */
+export const CALL_SITE_CACHE_CAPACITY = 16;
+// --- host values -----------------------------------------------------------
+/**
+ * A host value entering the engine — from an activation, from an implementation the host
+ * registered, or out of a host value a read reached into. A thenable is refused here rather
+ * than carried: an awaiting expression is an invocation in disguise, invisible to a journal
+ * and absent from a trace. The refusal itself lives in `cel-value.ts`, so every door answers
+ * with the same code and the same wording.
+ */
+export function readHostValue(value, range) {
+    return asyncValueRefused(value, range) ?? value;
+}
+// --- names -----------------------------------------------------------------
+/** A bare name: the activation's own entry, then the library's constants. */
+export function readName(activation, constants, name, range) {
+    if (activationHolds(activation, name))
+        return readHostValue(activation[name], range);
+    const held = constants.get(name);
+    if (held !== undefined)
+        return held;
+    return celError("no_such_variable", `no such variable: ${name}`, range);
+}
+/**
+ * One name read from the activation (or the library's constants), then its members. This
+ * is a chain whose split is already decided — at compile time, over the names the host
+ * declared (`declared-chain.ts`) — so evaluating it is one lookup plus member reads.
+ */
+export function readNameChain(activation, constants, name, rest, range) {
+    let held;
+    if (activationHolds(activation, name))
+        held = readHostValue(activation[name], range);
+    else {
+        const constant = constants.get(name);
+        if (constant === undefined)
+            return celError("no_such_variable", `no such variable: ${name}`, range);
+        held = constant;
+    }
+    for (const field of rest) {
+        if (isCelError(held))
+            return held;
+        held = readThrough(held, field, false, range);
+    }
+    return held;
+}
+/** Every prefix of a dotted chain, longest first, with the segments left to read. */
+export function prefixCandidates(segments) {
+    const candidates = [];
+    for (let length = segments.length; length >= 1; length -= 1) {
+        candidates.push({ name: segments.slice(0, length).join("."), rest: segments.slice(length) });
+    }
+    return candidates;
+}
+/**
+ * A chain **no** prefix of which the host declared: the activation is searched, longest
+ * prefix first. Every conformance row that binds a dotted key reads this way, and the
+ * checker has no opinion about such a chain either.
+ */
+export function searchNameChain(activation, constants, candidates, written, range) {
+    for (let at = 0; at < candidates.length; at += 1) {
+        const candidate = candidates[at];
+        if (!activationHolds(activation, candidate.name) && !constants.has(candidate.name))
+            continue;
+        return readNameChain(activation, constants, candidate.name, candidate.rest, range);
+    }
+    return celError("no_such_variable", `no such variable: ${written}`, range);
+}
+/**
+ * The dotted chain a select spells, when every step is a plain named member of a **free**
+ * name. A name a macro bound is a value, so a chain rooted at one is an ordinary member
+ * read — the same rule the checker applies, and the same answer both backends compile.
+ */
+export function plainMemberChain(node, bound) {
+    const segments = [];
+    let at = node;
+    while (at.kind === "select") {
+        if (at.optional || at.field === "")
+            return undefined;
+        segments.unshift(at.field);
+        at = at.operand;
+    }
+    if (at.kind !== "ident")
+        return undefined;
+    if (!at.absolute && bound(at.name))
+        return undefined;
+    segments.unshift(at.name);
+    return segments;
+}
+// --- member reads ----------------------------------------------------------
+/**
+ * A member read in every form. Reading **through an optional** answers an optional
+ * whichever form the read is written in, which is what lets a chain over a value that
+ * may be absent stay one expression: an absent one propagates as absent, and a key the
+ * held value does not have is absent too.
+ *
+ * Which refusals are absence and which are a mistake is `lookupAbsence`'s, and it turns
+ * on the FORM the read is written in rather than on what the operand turned out to be: a
+ * presence-shaped read over a value that holds no members is absent, while the ordinary
+ * read of a member of such a value is the mistake it is outside an optional too.
+ */
+export function readThrough(container, key, optionalForm, range) {
+    // The shape nearly every read has — a record's own string-keyed entry — decided by asking
+    // what the container is ONCE. The general path below is three total steps, so it reads the
+    // type key twice and the prototype again; this asks each question once and falls through
+    // to the one seam for every other container, every other key and every refusal.
+    if (!optionalForm && typeof key === "string" && typeof container === "object" && container !== null) {
+        if (container[CEL_VALUE_TYPE] === undefined) {
+            const prototype = Object.getPrototypeOf(container);
+            if ((prototype === Object.prototype || prototype === null) &&
+                Object.prototype.hasOwnProperty.call(container, key)) {
+                const held = container[key];
+                // The thenable door, inline: `readHostValue` is this test and nothing else.
+                if (typeof held !== "object" || held === null || typeof held.then !== "function") {
+                    return held;
+                }
+            }
+        }
+    }
+    if (isCelOptional(container)) {
+        if (!container.present)
+            return celNone();
+        return optionalRead(container.held, key, optionalForm, range);
+    }
+    if (optionalForm)
+        return optionalRead(container, key, true, range);
+    // **A member read is a door a host value comes through**, and the value it answers is
+    // whatever the host put inside its own object: `readHostValue` is what refuses a thenable
+    // there, rather than the aggregate, the operator or the exit that happens to see it next.
+    return readHostValue(celRead(container, key, range), range);
+}
+/**
+ * A read that answers an optional. `presence` is whether the read was WRITTEN in a
+ * presence-shaped form (`.?`, `[?]`), which is what decides whether a value holding no
+ * members is absence or a mistake.
+ */
+function optionalRead(container, key, presence, range) {
+    const found = celLookup(container, key);
+    if (typeof found !== "symbol") {
+        const held = readHostValue(found, range);
+        // A value that must be awaited is refused rather than carried as a present optional.
+        return isCelError(held) ? held : celSome(held);
+    }
+    if (lookupAbsence(found, presence))
+        return celNone();
+    return lookupError(found, key, range);
+}
+/**
+ * `has(a.b)` — presence, which a missing key and a value that holds no members both
+ * answer `false` for rather than erroring. An absent optional has no members, and a
+ * present one is asked about what it holds.
+ */
+export function hasMember(container, field, range) {
+    if (isCelOptional(container)) {
+        return container.present ? celHas(container.held, field, range) : false;
+    }
+    return celHas(container, field, range);
+}
+// --- operands --------------------------------------------------------------
+/** A bool operand, or the error it is — a non-bool is a mistake of its own. */
+export function boolOperand(value, range) {
+    if (typeof value === "boolean")
+        return value;
+    if (isCelError(value))
+        return value;
+    return celError("no_matching_overload", "this value is not a bool", range);
+}
+/** What an optional entry of an aggregate contributes, or the error it is not one. */
+export function optionalEntry(value, range) {
+    if (isCelOptional(value))
+        return value;
+    return celError("no_matching_overload", "an entry written with '?' holds an optional", range);
+}
+function dispatchOf(name, resolution) {
+    if ("resolved" in resolution) {
+        const host = resolution.resolved.metadata.implementation;
+        if (host)
+            return { implementation: host, foreign: true };
+        const own = implementationOf(resolution.resolved.signature);
+        return own ? { implementation: own, foreign: false } : null;
+    }
+    // **Equality is universal at runtime**, over every pair of types: the checker refuses
+    // `1 == 1u` deliberately, but `dyn(1) == 1u` reaches evaluation and cel-spec answers
+    // `true` there. A host's own registration still wins, because it resolved first.
+    const equality = equalityFallback(name);
+    return equality ? { implementation: equality, foreign: false } : null;
+}
+/** The universal equality, for a pair of types no registration names. */
+function equalityFallback(name) {
+    if (name !== "==" && name !== "!=")
+        return null;
+    return implementationOf({ name, form: "global", parameters: [], returns: DYN }) ?? null;
+}
+/**
+ * One call site, and the overloads it has resolved.
+ *
+ * **Overloads are resolved on the values' own types**, per site: `dyn(1.0) == 1` checks and
+ * must then answer across the numeric types, so the statically resolved signature is not
+ * enough. A site is almost always monomorphic, so the last resolution is held beside a
+ * bounded cache and reached by comparing the type names themselves — building a cache key
+ * per call is the allocation that costs most on the hottest path there is. A container's
+ * element type is read as `dyn` rather than walked, so dispatch does not get more expensive
+ * as the data gets larger.
+ *
+ * The arguments arrive **already evaluated and already free of errors**: carrying an
+ * error-valued operand out is the caller's, because only the caller knows how far it got.
+ */
+export class CallSite {
+    name;
+    form;
+    range;
+    registry;
+    nominalArity;
+    resolved = new BoundedCache(CALL_SITE_CACHE_CAPACITY);
+    context;
+    /** The arity the last resolution was made under; `-1` until there is one. */
+    count = -1;
+    t0;
+    t1;
+    t2;
+    t3;
+    lastDispatch = null;
+    constructor(name, form, range, registry, nominalArity) {
+        this.name = name;
+        this.form = form;
+        this.range = range;
+        this.registry = registry;
+        this.nominalArity = nominalArity;
+        this.context = { range };
+    }
+    call0() {
+        if (this.count === 0)
+            return this.answer(this.lastDispatch);
+        return this.resolve(0, undefined, undefined, undefined, undefined);
+    }
+    call1(a) {
+        if (this.count === 1 && celTypeNameOf(a) === this.t0)
+            return this.answer(this.lastDispatch, a);
+        return this.resolve(1, a, undefined, undefined, undefined);
+    }
+    call2(a, b) {
+        if (this.count === 2 && celTypeNameOf(a) === this.t0 && celTypeNameOf(b) === this.t1) {
+            return this.answer(this.lastDispatch, a, b);
+        }
+        return this.resolve(2, a, b, undefined, undefined);
+    }
+    call3(a, b, c) {
+        if (this.count === 3 &&
+            celTypeNameOf(a) === this.t0 &&
+            celTypeNameOf(b) === this.t1 &&
+            celTypeNameOf(c) === this.t2) {
+            return this.answer(this.lastDispatch, a, b, c);
+        }
+        return this.resolve(3, a, b, c, undefined);
+    }
+    call4(a, b, c, d) {
+        if (this.count === 4 &&
+            celTypeNameOf(a) === this.t0 &&
+            celTypeNameOf(b) === this.t1 &&
+            celTypeNameOf(c) === this.t2 &&
+            celTypeNameOf(d) === this.t3) {
+            return this.answer(this.lastDispatch, a, b, c, d);
+        }
+        return this.resolve(4, a, b, c, d);
+    }
+    /**
+     * The array form, for a caller that holds its arguments as one — a call written WIDER than
+     * any overload can be (`'42'.replace('2', '1', 1, false)` is five values, which is a row),
+     * the conformance and identity gates, and a host comparing a site cold against warm. It
+     * routes to the same entry points, so there is one dispatch path and not two.
+     */
+    call(values) {
+        switch (values.length) {
+            case 0:
+                return this.call0();
+            case 1:
+                return this.call1(values[0]);
+            case 2:
+                return this.call2(values[0], values[1]);
+            case 3:
+                return this.call3(values[0], values[1], values[2]);
+            case 4:
+                return this.call4(values[0], values[1], values[2], values[3]);
+            default:
+                return this.wide(values);
+        }
+    }
+    /**
+     * A call written with more values than the widest signature may declare. **The arity is
+     * the SOURCE's, not the dispatch key's** — anyone may write a call of any width — so this
+     * is reachable and answers the ordinary refusal, naming the types it was handed. Nothing
+     * resolves here, because a signature that wide is refused where it is registered; the
+     * resolution still runs, so one place decides what a call that resolves to nothing says.
+     */
+    wide(values) {
+        const names = new Array(values.length);
+        for (let at = 0; at < values.length; at += 1) {
+            const held = celTypeNameOf(values[at]);
+            if (held === undefined) {
+                const named = readHostValue(values[at], this.range);
+                if (isCelError(named))
+                    return named;
+                return celError("no_matching_overload", `${this.name} was handed a value of no CEL type`, this.range);
+            }
+            names[at] = held;
+        }
+        return celError("no_matching_overload", `no overload of ${JSON.stringify(this.name)} takes (${names.join(", ")})`, this.range);
+    }
+    resolve(count, a, b, c, d) {
+        const names = new Array(count);
+        for (let at = 0; at < count; at += 1) {
+            const value = at === 0 ? a : at === 1 ? b : at === 2 ? c : d;
+            const held = celTypeNameOf(value);
+            if (held === undefined) {
+                // A value of no CEL type. A **thenable** is one, and a thenable NESTED inside a host
+                // value arrives here rather than through the activation read, because a member read
+                // hands back what the host put there — and `resources.x.status.y` is exactly that
+                // shape, so this is the door a host actually uses. `readHostValue` names it for what
+                // it is; anything else is the overload failure it was going to be. The cost is on the
+                // slow path only: dispatch was about to fail either way.
+                const named = readHostValue(value, this.range);
+                if (isCelError(named))
+                    return named;
+                return celError("no_matching_overload", `${this.name} was handed a value of no CEL type`, this.range);
+            }
+            names[at] = held;
+        }
+        const key = names.join(",");
+        let dispatch = this.resolved.get(key);
+        if (dispatch === undefined) {
+            const types = names.map((unused, at) => runtimeType((at === 0 ? a : at === 1 ? b : at === 2 ? c : d), this.nominalArity));
+            const resolution = this.registry.resolve(this.name, this.form, this.form === "receiver" ? types.slice(1) : types, this.form === "receiver" ? types[0] : undefined);
+            dispatch = dispatchOf(this.name, resolution);
+            this.resolved.set(key, dispatch);
+        }
+        this.count = count;
+        this.t0 = names[0];
+        this.t1 = names[1];
+        this.t2 = names[2];
+        this.t3 = names[3];
+        this.lastDispatch = dispatch;
+        return this.answer(dispatch, a, b, c, d);
+    }
+    answer(dispatch, a, b, c, d) {
+        if (!dispatch) {
+            const names = [this.t0, this.t1, this.t2, this.t3].slice(0, Math.max(this.count, 0));
+            return celError("no_matching_overload", `no overload of ${JSON.stringify(this.name)} takes (${names.join(", ")})`, this.range);
+        }
+        const value = dispatch.implementation(this.context, a, b, c, d);
+        return dispatch.foreign ? readHostValue(value, this.range) : value;
+    }
+}
+/** A call site over an environment, which both backends build one of per call. */
+export function callSiteOf(target, name, form, range) {
+    return new CallSite(name, form, range, target.registry, target.nominalArity);
+}
+/**
+ * The type of a value, for dispatch. A container's element type is `dyn`: reading it
+ * exactly would mean walking the data on every call, and the registry's loose pass
+ * resolves a parameterized overload against `dyn` anyway.
+ */
+export function runtimeType(value, nominalArity) {
+    const name = celTypeNameOf(value);
+    switch (name) {
+        case "int":
+            return INT;
+        case "uint":
+            return UINT;
+        case "double":
+            return DOUBLE;
+        case "bool":
+            return BOOL;
+        case "string":
+            return STRING;
+        case "bytes":
+            return BYTES;
+        case "null_type":
+            return NULL;
+        case "type":
+            return TYPE;
+        case "google.protobuf.Timestamp":
+            return TIMESTAMP;
+        case "google.protobuf.Duration":
+            return DURATION;
+        case "list":
+            return listOf(DYN);
+        case "map":
+            return mapOf(DYN, DYN);
+        case "optional":
+            return optionalOf(DYN);
+        default: {
+            const arity = nominalArity(name) ?? 0;
+            return { kind: "nominal", name: name, base: DYN, args: Array.from({ length: arity }, () => DYN) };
+        }
+    }
+}

package/dist/bounded-cache.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A bounded least-recently-used cache.
+ *
+ * Every in-process cache in this engine is bounded with a declared capacity: a compiled
+ * expression, a compiled pattern and a call site's resolved overloads are all keyed on
+ * text a request can influence, so an unbounded cache is a memory leak with an author's
+ * input as its key. Eviction is least-recently-used, which a `Map` gives for free: its
+ * iteration order is insertion order, so re-inserting a hit moves it to the end and the
+ * first key is always the oldest untouched one.
+ */
+export declare class BoundedCache<Key, Value> {
+    readonly capacity: number;
+    private readonly held;
+    constructor(capacity: number);
+    get(key: Key): Value | undefined;
+    set(key: Key, value: Value): void;
+    /** Forgets everything — what a registration does to an environment's compiled programs. */
+    clear(): void;
+    get size(): number;
+}
+//# sourceMappingURL=bounded-cache.d.ts.map

package/dist/bounded-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-cache.d.ts","sourceRoot":"","sources":["../src/bounded-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,qBAAa,YAAY,CAAC,GAAG,EAAE,KAAK;IAGtB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAFrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyB;gBAEzB,QAAQ,EAAE,MAAM;IAMrC,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,KAAK,GAAG,SAAS;IAQhC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAQjC,2FAA2F;IAC3F,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/bounded-cache.js

@@ -0,0 +1,42 @@
+/**
+ * A bounded least-recently-used cache.
+ *
+ * Every in-process cache in this engine is bounded with a declared capacity: a compiled
+ * expression, a compiled pattern and a call site's resolved overloads are all keyed on
+ * text a request can influence, so an unbounded cache is a memory leak with an author's
+ * input as its key. Eviction is least-recently-used, which a `Map` gives for free: its
+ * iteration order is insertion order, so re-inserting a hit moves it to the end and the
+ * first key is always the oldest untouched one.
+ */
+export class BoundedCache {
+    capacity;
+    held = new Map();
+    constructor(capacity) {
+        this.capacity = capacity;
+        if (!Number.isInteger(capacity) || capacity < 1) {
+            throw new RangeError("a bounded cache holds at least one entry");
+        }
+    }
+    get(key) {
+        if (!this.held.has(key))
+            return undefined;
+        const value = this.held.get(key);
+        this.held.delete(key);
+        this.held.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        this.held.delete(key);
+        this.held.set(key, value);
+        if (this.held.size > this.capacity) {
+            this.held.delete(this.held.keys().next().value);
+        }
+    }
+    /** Forgets everything — what a registration does to an environment's compiled programs. */
+    clear() {
+        this.held.clear();
+    }
+    get size() {
+        return this.held.size;
+    }
+}

package/dist/catalog-runtime.d.ts

@@ -0,0 +1,59 @@
+/**
+ * What every function of the catalog **does** — once, for both backends.
+ *
+ * The declarations are data (`signatures/function-catalog.json`); this is the behaviour
+ * behind them, keyed by the same dispatch key the registry resolves on, exactly as
+ * `runtime-library.ts` is for CEL's own library. Both backends reach it through the
+ * registration's `implementation`, so there is one answer per operation and no second
+ * copy to drift.
+ *
+ * **Nine functions are the HOST's**, not this engine's: the four hashes, `hmac`, the two
+ * base64 string conversions, `json` and `joinPath`. Each needs a platform facility this
+ * package may not reach — a hash, a byte buffer, the host's own path separator — so the
+ * host supplies it through `CelCatalogHandlers` and a registration made without one
+ * answers an `unbound_function` error **naming the function**. Never a null, and never a
+ * silent empty string: a hash that answers nothing looks like a value and ends up in a
+ * cache key.
+ *
+ * **A refusal is worded by the catalog, in one voice** — `<function>: <what is wrong>` —
+ * and never by a library or by the host language's runtime. It is thrown as
+ * `CatalogRefusal` by the guard that meets it and turned into a CEL **error value** at
+ * exactly one place (`refusing`), so the short-circuit rules still hold and the static
+ * guard below reports the same sentence the evaluation would. Anything else thrown while
+ * an implementation runs is this engine failing, not the argument, and propagates.
+ */
+import type { CelImplementation } from "./runtime-library.js";
+import type { LiteralArgumentCheck } from "./signature.js";
+import type { CelValue } from "./cel-value.js";
+/**
+ * The nine functions the host answers for. Each needs a facility this package may not
+ * reach, which is the whole of why it is a seam: a hash and a byte buffer are the host
+ * platform's, and what a path separator IS belongs to the machine running the app.
+ */
+export interface CelCatalogHandlers {
+    sha256: (text: string) => string;
+    md5: (text: string) => string;
+    sha1: (text: string) => string;
+    sha512: (text: string) => string;
+    hmac: (algorithm: string, key: string, message: string) => string;
+    base64Encode: (text: string) => string;
+    base64Decode: (text: string) => string;
+    json: (value: CelValue) => string;
+    /** Join a relative path onto a base with the HOST's path rules. */
+    joinPath: (base: string, relative: string) => string;
+}
+/** An implementation, once the host's handlers are known. */
+export type CatalogImplementation = (handlers: Partial<CelCatalogHandlers>) => CelImplementation;
+/**
+ * The implementation of a catalog signature, given the host's handlers, or nothing where
+ * the catalog declares no such call. A declaration with no behaviour here is refused at
+ * registration rather than at evaluation.
+ */
+export declare function catalogImplementation(key: string, handlers: Partial<CelCatalogHandlers>): CelImplementation | undefined;
+/** Every dispatch key this file answers for, for a completeness check. */
+export declare function catalogImplementedKeys(): readonly string[];
+/** The literal guard of a catalog function, where it has one. */
+export declare function catalogLiteralCheck(name: string): LiteralArgumentCheck | undefined;
+/** Every function name a literal guard answers for, for a completeness check. */
+export declare function catalogGuardedNames(): readonly string[];
+//# sourceMappingURL=catalog-runtime.d.ts.map

package/dist/catalog-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-runtime.d.ts","sourceRoot":"","sources":["../src/catalog-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAEV,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAOV,QAAQ,EACT,MAAM,gBAAgB,CAAC;AA6BxB;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAClE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvC,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvC,IAAI,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,MAAM,CAAC;IAClC,mEAAmE;IACnE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CACtD;AAED,6DAA6D;AAC7D,MAAM,MAAM,qBAAqB,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,KAAK,iBAAiB,CAAC;AAstBjG;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,GACpC,iBAAiB,GAAG,SAAS,CAE/B;AAED,0EAA0E;AAC1E,wBAAgB,sBAAsB,IAAI,SAAS,MAAM,EAAE,CAE1D;AAkFD,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAElF;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,IAAI,SAAS,MAAM,EAAE,CAEvD"}