@telorun/cel 0.0.0-stage → 0.108.0

package/dist/cel-value.js

@@ -0,0 +1,225 @@
+/**
+ * The CEL value domain, and how a value says what it is.
+ *
+ * **Identity is a string type key under `Symbol.for("telo.cel.value")`, never
+ * `instanceof`.** Two copies of this engine loaded independently are two sets of
+ * classes, so a constructor check would make a `uint` built by one copy not a uint to
+ * the other — `+`, `type()` and every overload would refuse it. A symbol from the
+ * global registry is the same symbol in both, so the key is readable across copies,
+ * and because a symbol-keyed member cannot appear in parsed JSON an inbound request
+ * body cannot forge a duration. A plain object carrying a *string*-keyed look-alike
+ * (`{"telo.cel.value": "uint"}`) is therefore data: it reads as a map, as it must.
+ *
+ * What is **plain** carries no key, because the host platform already represents it
+ * one way and only one: `null`, a boolean, a string, a double (`number`), an int
+ * (`bigint`), bytes (`Uint8Array`), a list (an array) and a map whose keys are all
+ * strings (a plain object, which is how a host hands one over). What has no faithful
+ * plain form carries the key: a `uint` (a `bigint` is already an int), a timestamp and
+ * a duration (both nanosecond-precise, which no host date type holds), a type value,
+ * an optional, a map with typed keys, and a CEL error. A host's own named type
+ * registers its own key, checked against this set at registration.
+ *
+ * The keys are a **closed set** (`CEL_VALUE_KEYS`); a new one is a change here.
+ */
+export const CEL_VALUE_TYPE = Symbol.for("telo.cel.value");
+/** The type keys this engine owns. A host-registered type may not reuse one. */
+export const CEL_VALUE_KEYS = [
+    "uint",
+    "google.protobuf.Timestamp",
+    "google.protobuf.Duration",
+    "type",
+    "optional",
+    "map",
+    "error",
+];
+/** Every evaluation failure this engine names. A code is never derived from a message. */
+export const CEL_EVALUATION_CODES = [
+    /** A map or a record does not hold the key read. */
+    "no_such_key",
+    /** A name nothing in the activation holds, at any prefix. */
+    "no_such_variable",
+    /** A list index below zero or past the last element. */
+    "index_out_of_range",
+    /** No registered overload takes the values a call was handed. */
+    "no_matching_overload",
+    /** A select, an index or an iteration over a value that holds no members. */
+    "unsupported_container",
+    /** A map key, or an index, of a type no map is keyed by. */
+    "unsupported_key_type",
+    /** A map literal or a comprehension building two entries with one key. */
+    "duplicate_map_key",
+    /** An int or uint result outside its own range. */
+    "numeric_overflow",
+    "division_by_zero",
+    "modulo_by_zero",
+    /** A conversion the value cannot make: `int('x')`, `timestamp` out of range. */
+    "invalid_conversion",
+    /** An argument a function refuses: an unknown time zone, a negative index. */
+    "invalid_argument",
+    /** A pattern RE2 cannot parse. */
+    "invalid_regular_expression",
+    /** `value()` on an optional that holds nothing. */
+    "optional_value_missing",
+    /** A namespaced call nothing bound an implementation for. */
+    "unbound_function",
+    /** A thenable reached evaluation. Evaluation is synchronous on both backends. */
+    "async_value_unsupported",
+];
+// --- constructors ----------------------------------------------------------
+export function celUint(value) {
+    return { [CEL_VALUE_TYPE]: "uint", value };
+}
+export function celTypeValue(name) {
+    return { [CEL_VALUE_TYPE]: "type", name };
+}
+const NONE = { [CEL_VALUE_TYPE]: "optional", present: false };
+export function celNone() {
+    return NONE;
+}
+export function celSome(held) {
+    return { [CEL_VALUE_TYPE]: "optional", present: true, held };
+}
+export function celError(code, message, range) {
+    return { [CEL_VALUE_TYPE]: "error", code, message, ...(range ? { range } : {}) };
+}
+// --- reading what a value is ----------------------------------------------
+/** The type key a value carries, or nothing when it carries none. */
+function brandOf(value) {
+    const key = value[CEL_VALUE_TYPE];
+    return typeof key === "string" ? key : undefined;
+}
+export function isCelError(value) {
+    return typeof value === "object" && value !== null && brandOf(value) === "error";
+}
+export function isCelOptional(value) {
+    return typeof value === "object" && value !== null && brandOf(value) === "optional";
+}
+export function isCelUint(value) {
+    return typeof value === "object" && value !== null && brandOf(value) === "uint";
+}
+export function isCelMap(value) {
+    return typeof value === "object" && value !== null && brandOf(value) === "map";
+}
+export function isCelTimestamp(value) {
+    return typeof value === "object" && value !== null && brandOf(value) === "google.protobuf.Timestamp";
+}
+export function isCelDuration(value) {
+    return typeof value === "object" && value !== null && brandOf(value) === "google.protobuf.Duration";
+}
+export function isCelTypeValue(value) {
+    return typeof value === "object" && value !== null && brandOf(value) === "type";
+}
+/**
+ * Whether a value is bytes. `Object.prototype.toString` rather than `instanceof`, so a
+ * buffer built in another realm is still bytes — the same reason the brand is a
+ * registered symbol.
+ */
+export function isCelBytes(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Object.prototype.toString.call(value) === "[object Uint8Array]");
+}
+/**
+ * Whether a value is a map a host handed over: a plain object, not a branded one.
+ *
+ * The prototype decides, which is why nothing else needs checking: an array, a buffer and
+ * a class instance all have a prototype of their own, so none of them is a record. It is
+ * also the cheapest test there is, and this runs on every member read.
+ */
+export function isCelRecord(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return false;
+    return brandOf(value) === undefined;
+}
+/**
+ * The name of a value's CEL type, or nothing when the value is of no CEL type. It is
+ * what `type()` answers and what an overload is dispatched on, so it must answer for
+ * **any** value — `type()` has no `dyn` overload to fall back on.
+ */
+export function celTypeNameOf(value) {
+    switch (typeof value) {
+        case "boolean":
+            return "bool";
+        case "string":
+            return "string";
+        case "number":
+            return "double";
+        case "bigint":
+            return "int";
+        case "object":
+            break;
+        default:
+            return undefined;
+    }
+    if (value === null)
+        return "null_type";
+    const branded = brandOf(value);
+    if (branded !== undefined)
+        return branded === "error" ? undefined : branded;
+    // Ordered by what an expression meets most: a host's map, then a list, then bytes,
+    // whose test is the expensive one.
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === Object.prototype || prototype === null)
+        return "map";
+    if (Array.isArray(value))
+        return "list";
+    return isCelBytes(value) ? "bytes" : undefined;
+}
+/**
+ * A thenable reaching evaluation is refused, never passed along: evaluation is
+ * synchronous, and a promise flowing through an expression would be an invocation in
+ * disguise — invisible to a journal, absent from a trace, and unrepresentable as a
+ * step.
+ *
+ * The check is made at every **door** a host value comes through — an activation read, a
+ * registered implementation's result, a member read, an element entering a comprehension
+ * body, the value a name is bound to — and the list of them is in the package guide, which
+ * is where completeness is argued. `asyncValueRefused` is the one error they all answer
+ * with, so the code and the wording cannot drift between doors.
+ */
+export function isThenable(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.then === "function");
+}
+/**
+ * The refusal a value that must be awaited becomes, or nothing where it is an ordinary
+ * value.
+ *
+ * **A container is NOT walked**, and that is deliberate rather than a gap: a thenable inside
+ * a host list or map is refused when it becomes a value the engine reasons about — read by
+ * index, read as a member, or bound into a body — so every element costs one `typeof` when it
+ * is actually used, instead of every read costing a walk of what it returned.
+ */
+export function asyncValueRefused(value, range) {
+    if (!isThenable(value))
+        return undefined;
+    return celError("async_value_unsupported", "a value that must be awaited reached evaluation, and CEL evaluates synchronously", range);
+}
+/**
+ * The value a literal node denotes. A tagged literal is not a bare host value — `1` and
+ * `1u` are different expressions — so the one reading of a tag lives here, where both
+ * backends and the checker's literal-argument guard reach it rather than each keeping a
+ * switch of its own.
+ */
+export function literalValue(literal) {
+    switch (literal.type) {
+        case "int":
+            return literal.value;
+        case "uint":
+            return celUint(literal.value);
+        case "double":
+            return literal.value;
+        case "string":
+            return literal.value;
+        case "bytes":
+            return literal.value;
+        case "bool":
+            return literal.value;
+        case "null":
+            return null;
+    }
+}

package/dist/check-diagnostic.d.ts

@@ -0,0 +1,54 @@
+/**
+ * What the checker says, and the fact that **the checker says it**.
+ *
+ * Every verdict here carries its own code and the range of the text it is about. That
+ * is the whole point: an engine that reports one sentence for unrelated mistakes forces
+ * whoever consumes it to re-derive the cause afterwards from a registry it has to walk
+ * again — a classifier that can only ever explain, never decide, and that must stay
+ * silent on anything it cannot account for. The component that already knows decides
+ * here, once, and nothing downstream reads a message string.
+ *
+ * A **fix is a whole-source replacement**, never a sub-range splice. A CEL expression
+ * is usually one YAML scalar, an edit to it is applied by replacing that scalar, and a
+ * sub-range offset means something different the moment the scalar is re-indented.
+ */
+import type { SourceRange } from "./syntax-tree.js";
+/**
+ * Every verdict this engine decides. The type follows the list, so a code can only be
+ * added in one place and a host reading the vocabulary reads the same set the compiler
+ * holds every diagnostic to.
+ */
+export declare const CEL_CHECK_CODES: readonly ["CEL_SYNTAX_ERROR", "CEL_TYPE_ERROR", "CEL_UNKNOWN_IDENTIFIER", "CEL_UNKNOWN_FIELD", "CEL_UNKNOWN_FUNCTION", "CEL_WRONG_CALL_FORM", "CEL_TYPE_ARGUMENT_MISMATCH", "CEL_NULLABLE_ACCESS", "CEL_INVALID_ARGUMENT", "FUNCTION_UNRESOLVED", "FUNCTION_ARITY_MISMATCH", "FUNCTION_ARGUMENT_MISMATCH"];
+export type CelCheckCode = (typeof CEL_CHECK_CODES)[number];
+export interface CelDiagnosticFix {
+    /** The whole expression, corrected. */
+    readonly replacement: string;
+}
+export interface CelCheckDiagnostic {
+    readonly code: CelCheckCode;
+    readonly message: string;
+    readonly range: SourceRange;
+    readonly fix?: CelDiagnosticFix;
+}
+/**
+ * An engine error: the caller used the engine wrongly, so nothing is checked or
+ * compiled. It is not a verdict about the expression — `unreadable_expression` is the
+ * refusal to compile a tree the front end already reported a syntax diagnostic for,
+ * which is a question the caller should have asked before compiling, and
+ * `emitted_module_rejected` is the refusal to run a loaded module whose integrity header
+ * is not the one the emission asked for, and `signature_too_wide` is a registration
+ * declaring more values than an implementation receives.
+ */
+export type CelEngineErrorCode = "namespaces_mismatch" | "unreadable_expression" | "emitted_module_rejected" | "signature_too_wide";
+export declare class CelEngineError extends Error {
+    readonly code: CelEngineErrorCode;
+    constructor(code: CelEngineErrorCode, message: string);
+}
+/** Collects diagnostics in discovery order, which is source order for one pass. */
+export declare class DiagnosticList {
+    private readonly held;
+    add(diagnostic: CelCheckDiagnostic): void;
+    get length(): number;
+    list(): readonly CelCheckDiagnostic[];
+}
+//# sourceMappingURL=check-diagnostic.d.ts.map

package/dist/check-diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-diagnostic.d.ts","sourceRoot":"","sources":["../src/check-diagnostic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,eAAe,4SAyBlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAC1B,qBAAqB,GACrB,uBAAuB,GACvB,yBAAyB,GACzB,oBAAoB,CAAC;AAEzB,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;gBAEtB,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM;CAKtD;AAED,mFAAmF;AACnF,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IAEjD,GAAG,CAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI;IAIzC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,IAAI,SAAS,kBAAkB,EAAE;CAGtC"}

package/dist/check-diagnostic.js

@@ -0,0 +1,66 @@
+/**
+ * What the checker says, and the fact that **the checker says it**.
+ *
+ * Every verdict here carries its own code and the range of the text it is about. That
+ * is the whole point: an engine that reports one sentence for unrelated mistakes forces
+ * whoever consumes it to re-derive the cause afterwards from a registry it has to walk
+ * again — a classifier that can only ever explain, never decide, and that must stay
+ * silent on anything it cannot account for. The component that already knows decides
+ * here, once, and nothing downstream reads a message string.
+ *
+ * A **fix is a whole-source replacement**, never a sub-range splice. A CEL expression
+ * is usually one YAML scalar, an edit to it is applied by replacing that scalar, and a
+ * sub-range offset means something different the moment the scalar is re-indented.
+ */
+/**
+ * Every verdict this engine decides. The type follows the list, so a code can only be
+ * added in one place and a host reading the vocabulary reads the same set the compiler
+ * holds every diagnostic to.
+ */
+export const CEL_CHECK_CODES = [
+    /** The source could not be read at all (the front end's verdict, carried through). */
+    "CEL_SYNTAX_ERROR",
+    /** A type is not the one the expression needs here. */
+    "CEL_TYPE_ERROR",
+    /** A name nothing declares. */
+    "CEL_UNKNOWN_IDENTIFIER",
+    /** A member a declared type does not hold. */
+    "CEL_UNKNOWN_FIELD",
+    /** A function nothing registers. */
+    "CEL_UNKNOWN_FUNCTION",
+    /** A registered function called in the other form — `x.f()` for `f(x)`, or back. */
+    "CEL_WRONG_CALL_FORM",
+    /** A named type whose type argument differs from the one wanted. */
+    "CEL_TYPE_ARGUMENT_MISMATCH",
+    /** A dereference of something that may be null, with no guard proving it is not. */
+    "CEL_NULLABLE_ACCESS",
+    /** An argument a construct refuses on sight — a macro's variable that is not a name. */
+    "CEL_INVALID_ARGUMENT",
+    /** A namespaced call naming a function the namespace does not declare. */
+    "FUNCTION_UNRESOLVED",
+    /** A namespaced call with the wrong number of arguments. */
+    "FUNCTION_ARITY_MISMATCH",
+    /** A namespaced call whose argument is not the declared type. */
+    "FUNCTION_ARGUMENT_MISMATCH",
+];
+export class CelEngineError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "CelEngineError";
+        this.code = code;
+    }
+}
+/** Collects diagnostics in discovery order, which is source order for one pass. */
+export class DiagnosticList {
+    held = [];
+    add(diagnostic) {
+        this.held.push(diagnostic);
+    }
+    get length() {
+        return this.held.length;
+    }
+    list() {
+        return this.held;
+    }
+}

package/dist/checker.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The type checker: one walk, every verdict.
+ *
+ * It answers three things at once, because all three come from the same walk and
+ * nothing else can derive them: the type of the expression, every mistake in it with a
+ * range and a code, and which signature each call resolved to.
+ *
+ * Two properties are deliberate and worth keeping:
+ *
+ * - **One mistake is one diagnostic.** A subexpression that failed is typed `dyn`, so
+ *   the operator above it does not report a second mistake about the first one. An
+ *   editor shows what is wrong, not what is downstream of it.
+ * - **Nothing reads a message.** Every code is decided where the cause is known — an
+ *   unknown name, a call written in the other form, a type argument that differs — and
+ *   a repair, where there is an obvious one, is built by rewriting the tree and writing
+ *   it back out, so a fix is always a whole source that parses.
+ */
+import type { CelExpression } from "./cel-expression.js";
+import type { CelType } from "./cel-type.js";
+import type { CelCheckDiagnostic } from "./check-diagnostic.js";
+import type { FunctionRegistry } from "./function-registry.js";
+import type { ResolvedCall } from "./resolved-call.js";
+/**
+ * A namespaced function the host has declared.
+ *
+ * **The parameter list is optional, and withholding it is structural rather than a flag.**
+ * A host whose own signature grammar is richer than this engine's — optional trailing
+ * parameters, a declared JSON Schema per parameter — judges arity and arguments itself and
+ * declares only what this engine needs to type the call's RESULT. There is deliberately no
+ * way to supply parameters and ask for them not to be judged: that shape would let a
+ * declaration carry a list nothing reads, which is the state a reader cannot tell from a
+ * list that is simply wrong.
+ */
+export interface NamespaceFunction {
+    readonly name: string;
+    readonly returns: CelType;
+    /** Absent where the host withholds it; the call's arity and arguments are then unjudged. */
+    readonly parameters?: readonly CelType[];
+    /** How the declaration is written, for a listing; absent with the parameters. */
+    readonly signature?: string;
+    /**
+     * Types the declaration named that nothing is registered under, in the order written.
+     *
+     * The declaration is accepted and reads `dyn` where one stands: a host's declaration is
+     * data out of someone's manifest, so a name its own registry does not carry is the host
+     * disagreeing with itself — reported at the call, where there is a range, rather than
+     * thrown at registration, where there is none. Same rule as an unjudged schema node.
+     */
+    readonly unregisteredTypes?: readonly string[];
+    readonly deterministic?: boolean;
+    readonly hostBacked?: boolean;
+    readonly throws?: readonly string[];
+}
+export interface CheckerOptions {
+    readonly unlistedVariablesAreDyn: boolean;
+    readonly homogeneousAggregateLiterals: boolean;
+    readonly enableOptionalTypes: boolean;
+}
+/** Everything the checker reads about the environment it is checking against. */
+export interface CheckerContext {
+    readonly registry: FunctionRegistry;
+    readonly variable: (name: string) => CelType | undefined;
+    readonly declaredVariableNames: () => readonly string[];
+    readonly namespaceFunction: (namespace: string, name: string) => NamespaceFunction | undefined;
+    /**
+     * Whether a namespace declares every function reachable through it. An **open** namespace
+     * does not: a name it did not declare types `dyn`, is listed as a call, and is reported by
+     * nobody — the host resolves such a name against its own vocabulary (an export gate, a
+     * capability, a re-export chain) and words that verdict itself. Refusing it here would be
+     * this engine deciding a question only the host can answer, and the host would then have to
+     * suppress the refusal, which is the after-the-fact classifier this engine exists to retire.
+     */
+    readonly namespaceIsOpen: (namespace: string) => boolean;
+    readonly options: CheckerOptions;
+}
+export interface CheckResult {
+    readonly valid: boolean;
+    /** The type of the whole expression; `dyn` where something failed. */
+    readonly type: CelType;
+    /** How that type is written. */
+    readonly typeName: string;
+    readonly diagnostics: readonly CelCheckDiagnostic[];
+    readonly calls: readonly ResolvedCall[];
+}
+export declare function checkExpression(expression: CelExpression, context: CheckerContext): CheckResult;
+//# sourceMappingURL=checker.d.ts.map

package/dist/checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../src/checker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,eAAe,CAAC;AAyBzD,OAAO,KAAK,EAAgB,kBAAkB,EAAoB,MAAM,uBAAuB,CAAC;AAGhG,OAAO,KAAK,EAAE,gBAAgB,EAAyC,MAAM,wBAAwB,CAAC;AAKtG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAYvD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,4FAA4F;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACzC,iFAAiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,4BAA4B,EAAE,OAAO,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,qBAAqB,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;IACxD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IAC/F;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACzD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,WAAW,CAG/F"}