@intentius/chant-lexicon-terraform 0.124.52 → 0.124.54

package/dist/compose/estate.js

@@ -0,0 +1,363 @@
+/**
+ * The composed run of choudoufu estates (chant#4445, epic #4419): when every
+ * member runs choudoufu against a `live` estate (`Composition.estate`), one
+ * `choudoufu plan` and one `choudoufu apply` from a composed root of `module`
+ * calls (choudoufu#2059).
+ *
+ * An estate has no state file, so nothing is pulled, locked, split or
+ * written back: each resource's record goes to its own estate as it applies,
+ * and a `terraform_estate_outputs` read of another estate in the run is
+ * answered inside the run. The composed root is `writeEstateRoot`'s
+ * (./root.ts, #4441). The run takes the job's environment and assumes no
+ * role of its own: each estate's provider blocks name its role.
+ *
+ * choudoufu refuses a bare `show` under a `live` block, so the values the
+ * plan left unknown are read after the apply from a second plan of the
+ * composed root: its `prior_state`, sliced per module (./slice.ts, #4442) and
+ * read through `../applied-state`, the reader `chant terraform report` uses.
+ * The same plan says how far a failed apply got: a member whose part plans
+ * no change any more applied.
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (`ComposedRun` with `estate` set: `plan`, `apply`, `finishEstate`,
+ * `showEstateMembers`, `composedEnv`). The state-backed run is #4444; this one
+ * has the same `plan()`, `apply()` and `release()` and returns the same
+ * shapes, and #4447 picks one by `Composition.estate`.
+ */
+import { existsSync, mkdtempSync, readdirSync, rmdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { stateOutputs, stateResources } from "../applied-state.js";
+import { terraformPlanDigest } from "../plan-digest.js";
+import { terraformPlannedOutputs } from "../components/capability-plugin.js";
+import { computePlanDigest } from "@intentius/chant/lifecycle/plan-digest";
+import { isOlderVersion, MIN_CHOUDOUFU_ESTATES_VERSION, parseChoudoufuVersion } from "../op/activities/terraform.js";
+import { runBinary } from "../state/exec.js";
+import { memberApply } from "./apply-events.js";
+import { liveEstate } from "./hcl.js";
+import { stripModule, topModule } from "./module-address.js";
+import { COMPOSE_DIR, withoutVarFiles, writeEstateRoot } from "./root.js";
+import { composedMemberPlans, planCounts, slicePlan, sliceText } from "./slice.js";
+const firstLines = (s, n = 20) => s.trim().split("\n").slice(-n).join("\n");
+/**
+ * Why a choudoufu's `version` output cannot run a composed run of estates, or
+ * undefined when it can. A release older than
+ * {@link MIN_CHOUDOUFU_ESTATES_VERSION} falls back; a dev build names no
+ * release and passes.
+ */
+export function estateVersionFallback(versionOutput) {
+    const version = parseChoudoufuVersion(versionOutput);
+    if (version === undefined || !isOlderVersion(version, MIN_CHOUDOUFU_ESTATES_VERSION))
+        return undefined;
+    return {
+        kind: "binary",
+        reason: `choudoufu ${version} is older than v${MIN_CHOUDOUFU_ESTATES_VERSION}, the first release that plans and applies several estates as one (choudoufu#2059)`,
+    };
+}
+/**
+ * What choudoufu's human `apply` output says of each module: the changes
+ * that completed (`<addr>: Creation complete`, `Modifications complete`,
+ * `Destruction complete`), started (`Creating...` and the rest) or errored
+ * (an `Error:` box naming `with <addr>,`). An estate's apply runs under live
+ * resource markers and prints no `-json` lines, so this reads the text.
+ */
+export function readEstateApplyText(out, modules) {
+    const ev = { done: new Map(), started: new Map(), errored: new Map(), other: [] };
+    const known = new Set(modules);
+    const moduleOf = (addr) => {
+        const m = topModule(addr);
+        return m !== undefined && known.has(m) && addr !== `module.${m}` ? m : undefined;
+    };
+    const bump = (map, m) => {
+        map.set(m, (map.get(m) ?? 0) + 1);
+    };
+    const lines = out.split("\n").map((l) => l.replace(/^[│╷╵\s]+/, "").trimEnd());
+    for (let i = 0; i < lines.length; i++) {
+        const l = lines[i];
+        const hit = l.match(/^(module\.\S+): (Creation|Modifications|Destruction) complete\b/);
+        if (hit) {
+            const m = moduleOf(hit[1]);
+            if (m)
+                bump(ev.done, m);
+            continue;
+        }
+        const start = l.match(/^(module\.\S+): (Creating|Modifying|Destroying)\.\.\./);
+        if (start) {
+            const m = moduleOf(start[1]);
+            if (m)
+                bump(ev.started, m);
+            continue;
+        }
+        if (l.startsWith("Error: ")) {
+            let addr;
+            for (let j = i + 1; j < Math.min(lines.length, i + 8) && !lines[j].startsWith("Error: "); j++) {
+                const w = lines[j].match(/^with (module\.[^,\s]+),?$/);
+                if (w) {
+                    addr = w[1];
+                    break;
+                }
+            }
+            const m = addr ? moduleOf(addr) : undefined;
+            if (m && !ev.errored.has(m))
+                ev.errored.set(m, `${stripModule(addr)}: ${l}`);
+            else if (!m)
+                ev.other.push(l);
+        }
+    }
+    return ev;
+}
+/**
+ * Each member's outcome from its planned changes, what the apply printed, its
+ * exit code and, when the post-apply plan was made, the changes each member's
+ * part still plans. A clean exit means every planned change applied. After a
+ * failure, a member's changes left in the post-apply plan say how many of its
+ * planned changes applied; without that plan the printed completions do.
+ */
+export function estateOutcomes(c, planned, out, code, remaining) {
+    const ev = readEstateApplyText(out, c.order.map((member) => c.modules.get(member)));
+    for (const member of c.order) {
+        const m = c.modules.get(member);
+        const n = planned.get(member) ?? 0;
+        if (code === 0)
+            ev.done.set(m, n);
+        else if (remaining?.has(member))
+            ev.done.set(m, Math.max(0, n - remaining.get(member)));
+    }
+    const members = {};
+    for (const member of c.order) {
+        const m = c.modules.get(member);
+        const n = planned.get(member) ?? 0;
+        const { apply, done } = memberApply(m, n, ev);
+        const error = ev.errored.get(m);
+        members[member] = { status: apply, done, planned: n, ...(error && apply !== "applied" && apply !== "no-changes" ? { error } : {}) };
+    }
+    return { members, other: ev.other };
+}
+/**
+ * One composed run of estates: `plan()`, then `apply()` once the approval is
+ * given, then `release()` whatever happened. No call reads, locks or writes
+ * a state.
+ */
+export class EstateRun {
+    constructor(o) {
+        this.o = o;
+        const c = o.composition;
+        if (!c.estate || c.fallback || c.members.length < 2)
+            throw new Error(`EstateRun runs a composition of estates with two or more members${c.fallback ? `; this one fell back: ${c.fallback.reason}` : ""}`);
+        this.exec = o.exec ?? runBinary;
+        this.binary = o.binary ?? o.terraform.binary ?? "choudoufu";
+        this.composeDir = join(resolve(o.projectRoot), COMPOSE_DIR);
+        this.madeWork = o.work === undefined;
+        this.work = o.work ?? mkdtempSync(join(tmpdir(), "chant-compose-estate-"));
+    }
+    get c() {
+        return this.o.composition;
+    }
+    log(line) {
+        this.o.log?.(line);
+    }
+    /**
+     * The composed root's environment: the job's, with no role added (each
+     * estate's provider blocks name its role) and its `-var-file` flags taken
+     * out. With a shared provider cache and no lock file to check a cached
+     * provider against, the cache may fill the lock file.
+     */
+    env() {
+        const env = withoutVarFiles(this.o.env);
+        return env.TF_PLUGIN_CACHE_DIR && !existsSync(join(this.composeDir, ".terraform.lock.hcl")) ? { ...env, TF_PLUGIN_CACHE_MAY_BREAK_DEPENDENCY_LOCK_FILE: "true" } : env;
+    }
+    /** The estate each member's records go to: its root's `estate`, else its `live` block's. */
+    estateOf(member) {
+        const key = this.c.roots.get(member);
+        return (key !== undefined ? this.o.terraform.roots[key]?.estate : undefined) ?? liveEstate(this.c.dirs.get(member), this.binary).estate;
+    }
+    notPlanned(extra) {
+        return {
+            members: {},
+            digest: "",
+            planFile: join(this.work, "composed.tfplan"),
+            text: "",
+            texts: {},
+            generated: [],
+            counts: { add: 0, change: 0, destroy: 0, changes: 0, destroys: 0 },
+            summary: "",
+            ...extra,
+        };
+    }
+    /**
+     * Why this choudoufu cannot run the composition, or undefined. Runs
+     * `choudoufu version`; what #4447's `groupFallback` asks before planning.
+     */
+    async fallback() {
+        const v = await this.exec(this.binary, ["version"], resolve(this.o.projectRoot), this.o.env);
+        // A binary that cannot say its version is left to the plan, which says why it fails.
+        return v.code === 0 ? estateVersionFallback(v.stdout) : undefined;
+    }
+    writeRoot() {
+        this.root = writeEstateRoot({ projectRoot: this.o.projectRoot, composition: this.c });
+        return this.root;
+    }
+    restoreRoot() {
+        const r = this.root;
+        this.root = undefined;
+        r?.restore();
+    }
+    /**
+     * Check the binary's version, write the composed root, init it and plan
+     * once, then cut the plan into each member's part. The composed root is
+     * taken away again before this returns.
+     */
+    async plan() {
+        const fallback = await this.fallback();
+        if (fallback) {
+            this.log(`composed: ${fallback.reason}; the estates plan wave by wave`);
+            return this.notPlanned({ fallback });
+        }
+        let root;
+        try {
+            root = this.writeRoot();
+        }
+        catch (e) {
+            return this.notPlanned({ error: `the composed root could not be written: ${e.message}` });
+        }
+        const planFile = join(this.work, "composed.tfplan");
+        let plan;
+        let text = "";
+        let summary = "";
+        try {
+            const env = this.env();
+            const init = await this.exec(this.binary, ["init", "-input=false", "-no-color"], this.composeDir, env);
+            if (init.code !== 0)
+                return this.notPlanned({ error: `the composed root's init failed\n${firstLines(init.out)}` });
+            const p = await this.exec(this.binary, ["plan", "-input=false", "-no-color", `-out=${planFile}`], this.composeDir, env);
+            if (p.code !== 0)
+                return this.notPlanned({ error: `the composed plan failed\n${firstLines(p.out)}` });
+            summary = p.stdout.match(/Plan: .*|No changes\..*/)?.[0] ?? "planned";
+            const json = await this.exec(this.binary, ["show", "-json", planFile], this.composeDir, env);
+            try {
+                plan = JSON.parse(json.stdout);
+            }
+            catch {
+                return this.notPlanned({ error: `show -json printed no plan\n${firstLines(json.out, 6)}` });
+            }
+            text = (await this.exec(this.binary, ["show", "-no-color", planFile], this.composeDir, env)).stdout;
+        }
+        finally {
+            this.restoreRoot();
+        }
+        const members = composedMemberPlans(this.c, plan, { planner: "choudoufu", scope: (m) => this.estateOf(m) });
+        const texts = Object.fromEntries(this.c.order.map((m) => [m, sliceText(text, this.c.modules.get(m), members[m].counts)]));
+        const digest = computePlanDigest("terraform-compose-estate", { plan: terraformPlanDigest(plan), modules: this.c.order.map((m) => [m, this.c.modules.get(m)]), generated: root.generated });
+        this.planned = { members, digest, plan, planFile, text, texts, generated: root.generated, counts: planCounts(plan), summary };
+        return this.planned;
+    }
+    /**
+     * Apply the saved plan from the composed root, then plan again and read
+     * each member's values from that plan's `prior_state`. A failed apply
+     * leaves what applied applied, and each member's outcome says how far its
+     * part got.
+     */
+    async apply() {
+        const p = this.planned;
+        const notStarted = (error) => ({
+            ok: false,
+            members: Object.fromEntries(this.c.order.map((m) => [m, { status: "not-started", planned: p?.members[m]?.counts.changes ?? 0, done: 0 }])),
+            error,
+        });
+        if (!p?.plan)
+            return notStarted("the composed run did not plan");
+        let root;
+        try {
+            root = this.writeRoot();
+        }
+        catch (e) {
+            return notStarted(`the composed root could not be written: ${e.message}`);
+        }
+        let out = "";
+        let code = 1;
+        let after;
+        try {
+            if (JSON.stringify(root.generated) !== JSON.stringify(p.generated))
+                return notStarted("the composed root differs from the one planned, so nothing applied");
+            const a = await this.exec(this.binary, ["apply", "-input=false", "-no-color", p.planFile], this.composeDir, this.env());
+            out = a.out;
+            code = a.code;
+            for (const line of a.stdout.split("\n"))
+                if (line.trim())
+                    this.log(`composed: ${line}`);
+            after = await this.planAfter();
+        }
+        finally {
+            this.restoreRoot();
+        }
+        const planned = new Map(this.c.order.map((m) => [m, p.members[m].counts.changes]));
+        const slices = after !== undefined ? new Map(this.c.order.map((m) => [m, slicePlan(after, this.c.modules.get(m))])) : undefined;
+        const remaining = slices ? new Map(this.c.order.map((m) => [m, planCounts(slices.get(m)).changes])) : undefined;
+        const ended = estateOutcomes(this.c, planned, out, code, remaining);
+        const members = {};
+        for (const m of this.c.order) {
+            const row = { ...ended.members[m] };
+            const slice = slices?.get(m);
+            if (slice !== undefined) {
+                row.resources = stateResources(slice);
+                if (row.status === "applied" || row.status === "no-changes") {
+                    // A state choudoufu builds from records may carry no root outputs; the same plan's planned outputs, all known after the apply, stand in.
+                    const outputs = stateOutputs(slice);
+                    row.outputs = Object.keys(outputs).length > 0 ? outputs : terraformPlannedOutputs(slice).known;
+                }
+            }
+            members[m] = row;
+        }
+        const ok = code === 0 && Object.values(members).every((x) => x.status === "applied" || x.status === "no-changes");
+        const error = ok ? undefined : (ended.other[0] ?? Object.values(members).find((x) => x.error)?.error ?? "the composed apply failed");
+        return { ok, members, ...(after !== undefined ? { after } : {}), ...(error ? { error } : {}) };
+    }
+    /**
+     * `show -json` of a plan of the composed root made after the apply, whose
+     * `prior_state` choudoufu builds from the records and the live system.
+     * Undefined when it cannot be made: the values unknown at plan then stay
+     * unknown. Never fails the run.
+     */
+    async planAfter() {
+        const planFile = join(this.work, "composed-after.tfplan");
+        const env = this.env();
+        try {
+            const p = await this.exec(this.binary, ["plan", "-input=false", "-no-color", `-out=${planFile}`], this.composeDir, env);
+            if (p.code !== 0) {
+                this.log(`composed: the estates could not be planned after the apply; the values unknown at plan stay unknown\n${firstLines(p.out)}`);
+                return undefined;
+            }
+            const s = await this.exec(this.binary, ["show", "-json", planFile], this.composeDir, env);
+            if (s.code !== 0)
+                return undefined;
+            return JSON.parse(s.stdout);
+        }
+        catch (e) {
+            this.log(`composed: the estates could not be read after the apply (${e.message}); the values unknown at plan stay unknown`);
+            return undefined;
+        }
+    }
+    /**
+     * Take the composed root away if a call left it, with the binary's working
+     * files under `.chant-compose/`, and the plan files. There is no lock to
+     * let go of. Safe to call more than once.
+     */
+    async release() {
+        this.restoreRoot();
+        for (const f of [".terraform", ".terraform.lock.hcl"])
+            rmSync(join(this.composeDir, f), { recursive: true, force: true });
+        try {
+            if (existsSync(this.composeDir) && readdirSync(this.composeDir).length === 0)
+                rmdirSync(this.composeDir);
+        }
+        catch {
+            // Gone already.
+        }
+        if (this.madeWork)
+            rmSync(this.work, { recursive: true, force: true });
+        else
+            for (const f of ["composed.tfplan", "composed-after.tfplan"])
+                rmSync(join(this.work, f), { force: true });
+        this.planned = undefined;
+    }
+}

package/dist/compose/hcl.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The HCL a composition reads from a root's files (chant#4438): its backend
+ * and the state that backend names, its `terraform_remote_state` and
+ * `terraform_estate_outputs` reads, its `live` estate, the providers its lock
+ * file pins, and the local modules it calls.
+ *
+ * Lifted from terragucci at c493e0e (`compose.ts` `blankComments`,
+ * `lockedProviders`, `localModules`, `importLiteral`, `jsonBlocks`;
+ * `detect.ts` `blockBody`, `hclAttr`, `stateOf`, `estateOf`,
+ * `estateOutputReads`, `liveRoots`; `linked.ts` `configFiles`), reading a
+ * root's `-backend-config` from `terraform.roots.<name>.backendConfig` where
+ * terragucci read `TF_CLI_ARGS_init`. Regex over text with comments blanked,
+ * as there: no HCL parse runs.
+ */
+import { type Attr, type StateKey } from "./state-address.js";
+import { type ReadBackendInput } from "../state/backend.js";
+export type { StateKey } from "./state-address.js";
+/**
+ * HCL text with its comments blanked to spaces, newlines kept, so every
+ * position in it is the same position in the text as written. Strings and
+ * their escapes are read through, so a `#` or `//` in one stays.
+ */
+export declare function blankComments(text: string): string;
+/** The text of the block that starts at `start`: up to the brace that closes its first `{`. */
+export declare function blockBody(text: string, start: number): string;
+/**
+ * An HCL block's attribute: its string, `null` when it is written as anything
+ * but a plain string, undefined when it is not written.
+ */
+export declare const hclAttr: (body: string) => Attr;
+/**
+ * A root's own configuration files, not its modules', as paths: the set the
+ * root's `binary` reads (`.tf` and `.tf.json`, plus `.tofu` and `.tofu.json`
+ * for tofu or choudoufu), from the lexicon's one lister (chant#4457).
+ */
+export declare function configFiles(dir: string, binary?: string): string[];
+/** One configuration file's text, comments blanked when it is HCL. */
+export interface RootText {
+    file: string;
+    text: string;
+    json: boolean;
+}
+/** The text of a root's own configuration files, comments blanked so positions still match. */
+export declare function rootTexts(dir: string, binary?: string): RootText[];
+/** The blocks of a kind in a JSON-syntax file: `{"import": [...]}` or `{"import": {...}}`. */
+export declare function jsonBlocks(doc: unknown, kind: string): Record<string, unknown>[];
+/** A `terraform_remote_state` block: its label, the state it reads, and whether it repeats (count or for_each). */
+export interface RemoteStateRead extends StateKey {
+    name: string;
+    repeated: boolean;
+}
+/** What a root's code says about state: the state its backend keeps and the states its `terraform_remote_state` blocks read. */
+export interface RootState {
+    own?: StateKey;
+    reads: RemoteStateRead[];
+}
+/**
+ * The state the root at `dir` keeps, and the states its
+ * `terraform_remote_state` blocks read. `rel` is the root's directory
+ * relative to the project, which a `local` path resolves against.
+ *
+ * Which backend and which configuration name the root's own state is
+ * state/backend.ts's {@link readBackend} verdict (chant#4478): the code with
+ * the `-backend-config` flags of `TF_CLI_ARGS`, `TF_CLI_ARGS_init`,
+ * `backendConfigFiles` and `backendConfig` over it, and what `init` recorded
+ * once it has run. A key neither gives is read from the code's own block,
+ * which still names nested ones (a `cloud` or `remote` backend's
+ * `workspaces`). An address the code does not spell in plain strings is left
+ * out, so nothing lines up with it.
+ */
+export declare function rootState(dir: string, rel: string, input?: ReadBackendInput): RootState;
+/** Two addresses name one state: the same key, and the same bucket where both name one. */
+export declare const sameState: (a: StateKey, b: StateKey) => boolean;
+/**
+ * A choudoufu root's estate, from its `estate.chdf.hcl` or the `live` block in
+ * its `terraform` block; undefined when it declares none. A `live` block takes
+ * effect only under choudoufu, so the files read are the ones choudoufu reads
+ * unless `binary` names another.
+ */
+export declare function liveEstate(dir: string, binary?: string): {
+    live: boolean;
+    estate?: string;
+};
+/** Each `data "terraform_estate_outputs"` block of a root: its label and the estate whose outputs it reads. */
+export declare function estateOutputReads(dir: string, binary?: string): {
+    name: string;
+    estate: string;
+}[];
+/** The provider versions a root's lock file pins, by provider address. */
+export declare function lockedProviders(dir: string): Map<string, string>;
+/** Local module directories the root at `dir` calls (`source = "./..."` or `"../..."`), followed through, absolute. */
+export declare function localModules(dir: string, binary?: string): string[];
+/** `abs` relative to `from`, with `/` between parts, `.` for `from` itself. */
+export declare const relPath: (from: string, abs: string) => string;
+/** An `import` block the composed root can take as it is: a literal string id, no for_each, no provider of the root's own. */
+export declare function importLiteral(body: string): boolean;
+/** Whether a JSON-syntax `import` block takes no literal string id (or has for_each or a provider). */
+export declare function jsonImportRefused(text: string): boolean;
+//# sourceMappingURL=hcl.d.ts.map

package/dist/compose/hcl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hcl.d.ts","sourceRoot":"","sources":["../../src/compose/hcl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,EAAyB,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,EAAe,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEtE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqBlD;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAO7D;AAED;;;GAGG;AACH,eAAO,MAAM,OAAO,SACX,MAAM,KAAG,IAgBf,CAAC;AAEJ;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAElE;AAED,sEAAsE;AACtE,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;CACf;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAMlE;AAaD,8FAA8F;AAC9F,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAIhF;AAED,mHAAmH;AACnH,MAAM,WAAW,eAAgB,SAAQ,QAAQ;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,gIAAgI;AAChI,MAAM,WAAW,SAAS;IACxB,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,eAAe,EAAE,CAAC;CAC1B;AAWD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,GAAE,gBAAqB,GAAG,SAAS,CAsD3F;AAED,2FAA2F;AAC3F,eAAO,MAAM,SAAS,MAAO,QAAQ,KAAK,QAAQ,KAAG,OAA+E,CAAC;AAIrI;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAc,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBhG;AAED,+GAA+G;AAC/G,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,CAUlG;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAahE;AAED,uHAAuH;AACvH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBnE;AAED,+EAA+E;AAC/E,eAAO,MAAM,OAAO,SAAU,MAAM,OAAO,MAAM,KAAG,MAA0D,CAAC;AAE/G,8HAA8H;AAC9H,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED,uGAAuG;AACvG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD"}