@telorun/analyzer 0.57.0 → 0.58.0

package/dist/migrations/entry-data.js

@@ -0,0 +1,171 @@
+/** The on-disk shape of a migration entry, and its reader.
+ *
+ *  An entry is DATA: one file per entry under `analyzer/migrations/`, consumed
+ *  as one lexically ordered set. That is what makes adding a migration one file
+ *  and retiring one deleting it, what ships the set in the published package,
+ *  and what lets the Rust crate embed the identical files at build time rather
+ *  than reimplementing each rewrite.
+ *
+ *  **An entry contains no code.** Both halves — what a rule matches and what it
+ *  patches — are data, so one file is read identically by every kernel. A
+ *  predicate expressed in one language would mean one artifact is read two
+ *  ways, invisibly, since a migration that succeeds is silent.
+ *
+ *  Reading is STRICT. A malformed entry is an authoring mistake, and the
+ *  alternative to throwing is a migration that silently does not run — the one
+ *  failure mode a rewrite-on-load design cannot afford, because a migration
+ *  that succeeds and one that never fires look identical. */
+import { DiagnosticSeverity } from "../types.js";
+import { readMigrationMatch } from "./match.js";
+import { MIGRATION_OPS } from "./types.js";
+/** How an entry file names a severity. The LSP integers are a transport detail
+ *  of one editor; an entry is read by a Rust crate too. */
+const SEVERITIES = {
+    error: DiagnosticSeverity.Error,
+    warning: DiagnosticSeverity.Warning,
+    info: DiagnosticSeverity.Information,
+    hint: DiagnosticSeverity.Hint,
+};
+class MigrationEntryError extends Error {
+    constructor(file, detail) {
+        super(`Invalid migration entry '${file}': ${detail}`);
+        this.name = "MigrationEntryError";
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(file, node, key) {
+    const value = node[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new MigrationEntryError(file, `'${key}' must be a non-empty string`);
+    }
+    return value;
+}
+const OPERATION_KEYS = {
+    "rename-key": ["to"],
+    "set-value": ["value", "qualify"],
+    "set-tag": ["tag"],
+    "insert-item": ["value", "at"],
+    "remove-entry": [],
+};
+/** Top-level entry keys. `$comment` is the sanctioned place for author notes —
+ *  the reader ignores it, but it has to be DECLARED, or "unknown keys are
+ *  refused" would be true of every level but this one. */
+const ENTRY_KEYS = ["id", "code", "severity", "reason", "rules", "$comment"];
+/**
+ * A value a patch may write.
+ *
+ * Scalars only, because "every operation has a known YAML edit form" is what
+ * makes a migration applicable to a FILE, and the file applier renders a value
+ * by re-quoting it in the author's own style at the node's own span — which has
+ * no meaning for a mapping or a sequence. Without this check the limitation is
+ * invisible until a user runs `telo migrate` and is told, permanently, to fix
+ * it by hand; with it, the entry's author learns at authoring time. Structured
+ * values are a vocabulary extension (a block renderer), not a silent gap.
+ */
+function requireScalarValue(file, index, op, value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return;
+    }
+    throw new MigrationEntryError(file, `patch[${index}] ('${op}') value must be a scalar (string, number, boolean or null) — ` +
+        `a mapping or sequence has no in-place YAML edit form, so \`telo migrate\` could never apply it`);
+}
+function readOperation(file, raw, index) {
+    if (!isPlainObject(raw)) {
+        throw new MigrationEntryError(file, `patch[${index}] must be a mapping`);
+    }
+    const op = raw.op;
+    if (typeof op !== "string" || !MIGRATION_OPS.includes(op)) {
+        throw new MigrationEntryError(file, `patch[${index}].op '${String(op)}' is not one of ${MIGRATION_OPS.join(", ")}`);
+    }
+    // The vocabulary is closed, so an unknown parameter is a typo — and a typo in
+    // a patch is a rewrite that quietly does something other than what it reads
+    // as. `set-value`'s two parameters are alternatives, checked below.
+    const allowed = new Set([...OPERATION_KEYS[op], "op"]);
+    for (const key of Object.keys(raw)) {
+        if (!allowed.has(key)) {
+            throw new MigrationEntryError(file, `patch[${index}] ('${op}') has no parameter '${key}'`);
+        }
+    }
+    switch (op) {
+        case "rename-key":
+            return { op, to: requireString(file, raw, "to") };
+        case "set-value": {
+            const hasValue = Object.hasOwn(raw, "value");
+            const hasQualify = Object.hasOwn(raw, "qualify");
+            if (hasValue === hasQualify) {
+                throw new MigrationEntryError(file, `patch[${index}] ('set-value') takes exactly one of 'value' or 'qualify'`);
+            }
+            if (hasQualify)
+                return { op, qualify: requireString(file, raw, "qualify") };
+            requireScalarValue(file, index, op, raw.value);
+            return { op, value: raw.value };
+        }
+        case "set-tag":
+            return { op, tag: requireString(file, raw, "tag") };
+        case "insert-item": {
+            if (!Object.hasOwn(raw, "value")) {
+                throw new MigrationEntryError(file, `patch[${index}] ('insert-item') requires 'value'`);
+            }
+            requireScalarValue(file, index, op, raw.value);
+            const at = raw.at;
+            if (at !== undefined && (typeof at !== "number" || !Number.isInteger(at) || at < 0)) {
+                throw new MigrationEntryError(file, `patch[${index}].at must be a non-negative integer when present`);
+            }
+            return at === undefined ? { op, value: raw.value } : { op, value: raw.value, at };
+        }
+        case "remove-entry":
+            return { op };
+        default:
+            throw new MigrationEntryError(file, `patch[${index}].op '${op}' is unhandled`);
+    }
+}
+function readRule(file, raw, index) {
+    if (!isPlainObject(raw)) {
+        throw new MigrationEntryError(file, `rules[${index}] must be a mapping`);
+    }
+    if (!Array.isArray(raw.patch) || raw.patch.length === 0) {
+        throw new MigrationEntryError(file, `rules[${index}].patch must be a non-empty sequence`);
+    }
+    return {
+        match: readMigrationMatch(`Invalid migration entry '${file}': rules[${index}]`, raw.match),
+        patch: raw.patch.map((op, i) => readOperation(file, op, i)),
+    };
+}
+/**
+ * Read one entry file's parsed data into a `MigrationEntry`.
+ *
+ * `file` names the entry file, so a failure says which one.
+ */
+export function parseMigrationEntry(file, data) {
+    if (!isPlainObject(data)) {
+        throw new MigrationEntryError(file, "an entry must be a mapping");
+    }
+    // Closed at every level, this one included: a typo'd top-level key would
+    // otherwise be silently ignored, which is the one failure a rewrite-on-load
+    // design cannot afford once module-shipped entries make this a trust boundary.
+    for (const key of Object.keys(data)) {
+        if (!ENTRY_KEYS.includes(key)) {
+            throw new MigrationEntryError(file, `an entry has no key '${key}'. Known keys: ${ENTRY_KEYS.join(", ")}.`);
+        }
+    }
+    const severityName = requireString(file, data, "severity");
+    const severity = SEVERITIES[severityName];
+    if (severity === undefined) {
+        throw new MigrationEntryError(file, `severity '${severityName}' must be one of ${Object.keys(SEVERITIES).join(", ")}`);
+    }
+    if (!Array.isArray(data.rules) || data.rules.length === 0) {
+        throw new MigrationEntryError(file, "'rules' must be a non-empty sequence");
+    }
+    return {
+        id: requireString(file, data, "id"),
+        code: requireString(file, data, "code"),
+        severity,
+        reason: requireString(file, data, "reason").trim(),
+        rules: data.rules.map((rule, i) => readRule(file, rule, i)),
+    };
+}

package/dist/migrations/index.d.ts

@@ -0,0 +1,22 @@
+/** The migration mechanism's surface — what a consumer OUTSIDE this directory
+ *  may hold.
+ *
+ *  Deliberately narrow. The matcher, the patch planner and the two appliers are
+ *  one mechanism with one entry point per job (`migrateManifests` for the
+ *  loader, `migrateFileText` for `telo migrate`, `remapMigratedPaths` for a
+ *  diagnostic consumer); re-exporting their internals would make the plan/apply
+ *  split, the effect vocabulary and the text-edit shape semver-bound API with
+ *  no caller, and freeze the one part most likely to change as the operation
+ *  vocabulary grows.
+ *
+ *  The entry-set trio (`CORE_MIGRATIONS`, `parseMigrationEntry`,
+ *  `MigrationEntry`) is here because `LoaderInitOptions.migrations` is a
+ *  composition-root seam: a host aggregating module-shipped entries beside the
+ *  core ones needs to read one and to name the set it is extending. */
+export { migrateFileText, migrateManifests, NO_MIGRATIONS } from "./driver.js";
+export type { FileMigrations } from "./driver.js";
+export { parseMigrationEntry } from "./entry-data.js";
+export { remapMigratedPaths } from "./provenance.js";
+export { CORE_MIGRATIONS } from "./registry.js";
+export type { MigrationEntry, MigrationRewrite } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;uEAcuE;AAEvE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/E,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC"}

package/dist/migrations/index.js

@@ -0,0 +1,19 @@
+/** The migration mechanism's surface — what a consumer OUTSIDE this directory
+ *  may hold.
+ *
+ *  Deliberately narrow. The matcher, the patch planner and the two appliers are
+ *  one mechanism with one entry point per job (`migrateManifests` for the
+ *  loader, `migrateFileText` for `telo migrate`, `remapMigratedPaths` for a
+ *  diagnostic consumer); re-exporting their internals would make the plan/apply
+ *  split, the effect vocabulary and the text-edit shape semver-bound API with
+ *  no caller, and freeze the one part most likely to change as the operation
+ *  vocabulary grows.
+ *
+ *  The entry-set trio (`CORE_MIGRATIONS`, `parseMigrationEntry`,
+ *  `MigrationEntry`) is here because `LoaderInitOptions.migrations` is a
+ *  composition-root seam: a host aggregating module-shipped entries beside the
+ *  core ones needs to read one and to name the set it is extending. */
+export { migrateFileText, migrateManifests, NO_MIGRATIONS } from "./driver.js";
+export { parseMigrationEntry } from "./entry-data.js";
+export { remapMigratedPaths } from "./provenance.js";
+export { CORE_MIGRATIONS } from "./registry.js";

package/dist/migrations/match.d.ts

@@ -0,0 +1,162 @@
+/** The selector half of a migration: what a rule MATCHES, as data.
+ *
+ *  A patch addresses a known location; a migration has to find *every*
+ *  occurrence of a legacy spelling, so selection is the half a plain patch
+ *  format has none of. It is declarative for the same reason the operations
+ *  are: an entry travels to a Rust and a Go kernel, and a predicate expressed
+ *  in one language would mean one artifact is read two ways — invisibly, since
+ *  a migration that succeeds is silent.
+ *
+ *  **Containment is POSITIVE and required.** A rule states which document kinds
+ *  it may touch (`inKind`) and which region of those documents it may reach
+ *  into (`under`); nothing outside is reachable. The alternative — walk
+ *  everything and subtract — cannot be made sound, because the set to subtract
+ *  is unbounded: a `Run.Value` value, an `Assert.Equals` expected, any kind
+ *  whose config carries a user JSON blob can hold something shaped like the
+ *  node a rule looks for, and forgetting one corrupts a manifest with no
+ *  diagnostic. A denylist also cannot express the guarantee the module surface
+ *  is promised to carry — *a dependency can rename its own field and provably
+ *  nothing else* — which is a statement about what a rule may reach, so it has
+ *  to be said positively. `notUnder` remains for subtracting inside a region a
+ *  rule legitimately reaches, which is a narrowing, not the containment itself.
+ *
+ *  **`under` is ANCHORED at the document root**, not a set of key names to look
+ *  for anywhere on the path. Anchoring is what makes the containment claim
+ *  true: a `Telo.Definition`'s `resources:` template body carries other kinds'
+ *  configuration, and any of it may hold a key spelled `schema` over data that
+ *  merely looks like a schema — so "some segment of the path is `schema`" would
+ *  reach the very user JSON blob the positive form exists to keep out, and
+ *  would delete from it silently. Anchored, `under` names top-level document
+ *  keys and a region is a genuine subtree.
+ *
+ *  **`inSchema` is the one region a kind list cannot name.** An annotation
+ *  keyword occurs in author-written JSON Schema, and schema fragments are not
+ *  confined to kind documents: an inline `inputType:` / `outputType:` on ANY kind
+ *  that declares one, an API route's `request.schema.body`, a `Telo.JsonSchema`'s
+ *  `schema`. That set of kinds is open — any kind may declare a schema-valued
+ *  field — and enumerating the standard library's would put resource-kind
+ *  knowledge into the analyzer, against the topology-driven constraint. So a rule
+ *  may instead state that it reaches only inside a SCHEMA REGION, named by the
+ *  KERNEL's own schema-valued keys, which no kind owns.
+ *
+ *  With `inSchema`, and only with it, `inKind` / `under` may be `["*"]` — and
+ *  only for a rule keyed on a reserved `x-telo-*` annotation. That pairing IS the
+ *  containment: the region gate bounds where the walk may go, and the reserved-key
+ *  rule bounds what it may touch, since an `x-telo-*` key is Telo vocabulary
+ *  wherever it appears and cannot mean something else in someone's config. Both
+ *  halves are refused at entry-read time, so a module-shipped entry can no more
+ *  spell `"*"` than it can name another module's kind.
+ *
+ *  The residue is stated rather than claimed away: a manifest that asserts ABOUT
+ *  a schema — a schema literal under a key spelled `schema` inside an assertion's
+ *  expected value — is reachable, and would be rewritten into its own synonym.
+ *  That cannot be closed in a data-only matcher without naming kinds. It is
+ *  accepted because the sites the wildcards reach are exactly the ones no
+ *  enumeration covers, and the alternative leaves an author reading a deprecation
+ *  `telo migrate` refuses to act on.
+ *
+ *  The vocabulary is closed, which is what makes it a trust boundary once
+ *  module-shipped entries are aggregated beside core ones. An unrecognized key
+ *  is refused rather than ignored — a selector that silently matches wider than
+ *  it reads is the one failure this cannot tolerate. */
+import type { MigrationPath } from "./types.js";
+/** The wildcard `inKind` / `under` value. Legal only alongside `inSchema`, and
+ *  only for a rule keyed on an `x-telo-*` annotation. */
+export declare const MATCH_ANY = "*";
+export interface MigrationMatch {
+    /** The mapping key this rule rewrites. */
+    readonly key: string;
+    /** Document `kind:` values this rule may match in. Required and non-empty:
+     *  a rule that does not say which documents it touches cannot be reasoned
+     *  about, and is exactly the rule that reaches into a resource's config. */
+    readonly inKind: readonly string[];
+    /** The region of the document this rule may reach, named by TOP-LEVEL
+     *  document keys: the matched node must be AT or BELOW one of them. Required
+     *  and non-empty, for the same reason as `inKind`.
+     *
+     *  Anchored at the root rather than matched anywhere on the path — see the
+     *  file header; an unanchored `under` reaches into a nested resource's own
+     *  configuration and is not containment at all.
+     *
+     *  At-or-below rather than strictly-below so the vocabulary is complete — a
+     *  rule that rewrites a top-level key names that key, instead of the region
+     *  being unreachable and the grammar needing a second spelling for the
+     *  document root. */
+    readonly under: readonly string[];
+    /** The value must deep-equal this. Mutually exclusive with `valueOneOf`. */
+    readonly value?: unknown;
+    /** The value must be one of these. Matching against the KNOWN legacy values
+     *  rather than any value is what leaves an unrecognized one alone for the
+     *  ordinary validator to report, instead of silently rewriting it. */
+    readonly valueOneOf?: readonly unknown[];
+    /** A key that must be present in the same mapping. The matched key is often
+     *  stale only *because* of what sits beside it. */
+    readonly withSibling?: string;
+    /** Ancestor keys that disqualify a match inside the region `under` allows.
+     *  The data-bearing JSON Schema keywords (`const`, `default`, `enum`,
+     *  `examples`) hold values that may look like schemas. */
+    readonly notUnder?: readonly string[];
+    /** Narrow to a JSON Schema region: the match must be at or below a node
+     *  reached through one of {@link SCHEMA_REGION_KEYS}.
+     *
+     *  A second bound, never a replacement for `inKind` / `under` — it is what
+     *  makes their wildcard forms safe, and it narrows an enumerated region just as
+     *  usefully. See the file header for why an annotation rename needs it. */
+    readonly inSchema?: boolean;
+}
+export declare const MATCH_KEYS: readonly ["key", "inKind", "under", "value", "valueOneOf", "withSibling", "notUnder", "inSchema"];
+/** Structural equality over JSON values — what `value` / `valueOneOf` compare
+ *  with, so a match on `true` never also matches `"true"`.
+ *
+ *  Exported because the PATCHER asks the same question in the other direction:
+ *  "is the value already what this would write". Both answers have to come from
+ *  one rule, or a rule could match a spelling the patch then declares current. */
+export declare function deepEquals(a: unknown, b: unknown): boolean;
+/** Read a rule's `match` block, refusing anything the vocabulary does not
+ *  define. `describe` names the entry and rule so a failure says which. */
+export declare function readMigrationMatch(describe: string, raw: unknown): MigrationMatch;
+/** One candidate site: a mapping entry whose key some rule is interested in. */
+interface MatchSite {
+    readonly path: MigrationPath;
+    readonly value: unknown;
+    readonly parent: Record<string, unknown>;
+}
+/** Every candidate site in one document, keyed by mapping key.
+ *
+ *  Built ONCE per document and shared by every rule that can apply to it,
+ *  because the walk is the expensive part and it does not depend on the rule —
+ *  this is on the kernel's boot path for every file in the graph, so a walk per
+ *  rule would scale the cost of loading any manifest with the size of the
+ *  migration set.
+ *
+ *  The walk is bounded by the same containment the rules declare: `roots` is
+ *  the union of the applicable rules' `under`, so a region no rule can reach is
+ *  never descended into and a document no rule can match is never walked at
+ *  all. Only keys some rule asked for allocate a path array. */
+export type MatchIndex = ReadonlyMap<string, readonly MatchSite[]>;
+/**
+ * Index `document`'s candidate sites for `keys`, descending only into the
+ * top-level regions named by `roots`.
+ *
+ * The caller has already gated on `inKind` — see `selectMatches`, which repeats
+ * the check because it holds the individual rule.
+ */
+export declare function buildMatchIndex(document: unknown, keys: ReadonlySet<string>, roots: ReadonlySet<string>): MatchIndex;
+/** The rules in `entries` that may match a document of `kind`, with the key and
+ *  root sets their shared index needs. Empty rules mean the document is not
+ *  walked at all. */
+export declare function applicableRules<T extends {
+    readonly match: MigrationMatch;
+}>(rules: Iterable<T>, kind: unknown): {
+    rules: T[];
+    keys: Set<string>;
+    roots: Set<string>;
+};
+/** The sites in `index` this match selects, in document order. */
+export declare function selectMatches(index: MatchIndex, document: unknown, match: MigrationMatch): MigrationPath[];
+/** Convenience for a single match against a document — builds a one-rule index.
+ *  The driver uses `applicableRules` + `buildMatchIndex` + `selectMatches` so
+ *  one walk serves every rule that can reach the document. */
+export declare function findMatches(document: unknown, match: MigrationMatch): MigrationPath[];
+export {};
+//# sourceMappingURL=match.d.ts.map

package/dist/migrations/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../src/migrations/match.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDA4DwD;AAGxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;yDACyD;AACzD,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;gFAE4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;;;;;;;yBAWqB;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB;;0EAEsE;IACtE,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACzC;uDACmD;IACnD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;8DAE0D;IAC1D,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;;+EAK2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,eAAO,MAAM,UAAU,mGASb,CAAC;AAMX;;;;;kFAKkF;AAClF,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAY1D;AAUD;2EAC2E;AAC3E,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,cAAc,CA6EjF;AAED,gFAAgF;AAChF,UAAU,SAAS;IACjB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;gEAWgE;AAChE,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC;AAEnE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,UAAU,CA6CZ;AAED;;qBAEqB;AACrB,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;CAAE,EAC1E,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,IAAI,EAAE,OAAO,GACZ;IAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAYvD;AAQD,kEAAkE;AAClE,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,cAAc,GACpB,aAAa,EAAE,CA4BjB;AAED;;8DAE8D;AAC9D,wBAAgB,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,GAAG,aAAa,EAAE,CAGrF"}