@stevenvo780/st-lang 4.5.2 → 4.6.0

package/dist/tactic-dsl/combinators.d.ts

@@ -0,0 +1,6 @@
+import type { Tactic } from './types';
+export declare function seq(...tactics: Tactic[]): Tactic;
+export declare function orElse(...tactics: Tactic[]): Tactic;
+export declare function repeat_(t: Tactic, max?: number): Tactic;
+export declare function tryAlt(t: Tactic): Tactic;
+//# sourceMappingURL=combinators.d.ts.map

package/dist/tactic-dsl/combinators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combinators.d.ts","sourceRoot":"","sources":["../../src/tactic-dsl/combinators.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAc,MAAM,EAAE,MAAM,SAAS,CAAC;AAMlD,wBAAgB,GAAG,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAQhD;AAMD,wBAAgB,MAAM,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAmBnD;AAOD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAM,GAAG,MAAM,CAqBpD;AAMD,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQxC"}

package/dist/tactic-dsl/combinators.js

@@ -0,0 +1,98 @@
+"use strict";
+// ============================================================
+// Tactic DSL — combinators
+// ============================================================
+//
+// seq / orElse / repeat_ / tryAlt: combinadores estándar al estilo
+// Coq/Ltac. Operan sobre Tactic = (state) => state, lanzando
+// TacticError para señalizar falla.
+//
+// Nota sobre el nombre `seq`: la API conceptual de Lean/Coq usa el
+// nombre `then` o `;`. NO podemos exportar un símbolo top-level
+// llamado `then` desde un módulo ESM porque el bundler de vitest
+// trata al namespace del módulo como un thenable y cuelga el import.
+// Por compatibilidad con la documentación del DSL, el index re-expone
+// `seq` también bajo el alias `then` vía objeto namespace (ver
+// `tactics` exportado desde index.ts).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seq = seq;
+exports.orElse = orElse;
+exports.repeat_ = repeat_;
+exports.tryAlt = tryAlt;
+const types_1 = require("./types");
+// ---------- seq ----------
+// Aplica los tactics en secuencia. Si alguno falla, propaga el error
+// (estado intermedio descartado). Equivalente a `then` en Coq.
+function seq(...tactics) {
+    return (state) => {
+        let cur = state;
+        for (const t of tactics) {
+            cur = t(cur);
+        }
+        return cur;
+    };
+}
+// ---------- orElse ----------
+// Devuelve el resultado del primer tactic que no lanza. Si todos
+// fallan, lanza TacticError con el último mensaje.
+function orElse(...tactics) {
+    return (state) => {
+        let lastErr = null;
+        for (const t of tactics) {
+            try {
+                return t(state);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    lastErr = e;
+                    continue;
+                }
+                throw e;
+            }
+        }
+        throw new types_1.TacticError('orElse', `todas las alternativas fallaron${lastErr ? `: ${lastErr.message}` : ''}`);
+    };
+}
+// ---------- repeat_ ----------
+// Aplica `t` mientras pueda. Detiene cuando lanza o cuando alcanza
+// `max` iteraciones (default 100). Nunca falla: si t no aplica ni
+// una vez, devuelve el estado original.
+function repeat_(t, max = 100) {
+    return (state) => {
+        let cur = state;
+        let i = 0;
+        while (i < max) {
+            let next;
+            try {
+                next = t(cur);
+            }
+            catch {
+                return cur;
+            }
+            // Guard contra punto fijo: si el estado no cambia (mismas goals + history),
+            // paramos para evitar bucles tipo `repeat_(trivial())` cuando el goal ya
+            // está cerrado.
+            if (next === cur)
+                return cur;
+            if (next.done)
+                return next;
+            cur = next;
+            i++;
+        }
+        return cur;
+    };
+}
+// ---------- tryAlt ----------
+// Aplica `t` ignorando la falla. Util para "intenta esto, sigue
+// adelante si no aplica". Nombre `tryAlt` por colisión con keyword.
+function tryAlt(t) {
+    return (state) => {
+        try {
+            return t(state);
+        }
+        catch {
+            return state;
+        }
+    };
+}
+//# sourceMappingURL=combinators.js.map

package/dist/tactic-dsl/combinators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"combinators.js","sourceRoot":"","sources":["../../src/tactic-dsl/combinators.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,2BAA2B;AAC3B,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,6DAA6D;AAC7D,oCAAoC;AACpC,EAAE;AACF,mEAAmE;AACnE,gEAAgE;AAChE,iEAAiE;AACjE,qEAAqE;AACrE,sEAAsE;AACtE,+DAA+D;AAC/D,uCAAuC;;AASvC,kBAQC;AAMD,wBAmBC;AAOD,0BAqBC;AAMD,wBAQC;AAlFD,mCAAsC;AAGtC,4BAA4B;AAC5B,qEAAqE;AACrE,+DAA+D;AAE/D,SAAgB,GAAG,CAAC,GAAG,OAAiB;IACtC,OAAO,CAAC,KAAK,EAAE,EAAE;QACf,IAAI,GAAG,GAAG,KAAK,CAAC;QAChB,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACxB,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACf,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;AACJ,CAAC;AAED,+BAA+B;AAC/B,iEAAiE;AACjE,mDAAmD;AAEnD,SAAgB,MAAM,CAAC,GAAG,OAAiB;IACzC,OAAO,CAAC,KAAK,EAAE,EAAE;QACf,IAAI,OAAO,GAAiB,IAAI,CAAC;QACjC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACxB,IAAI,CAAC;gBACH,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,YAAY,KAAK,EAAE,CAAC;oBACvB,OAAO,GAAG,CAAC,CAAC;oBACZ,SAAS;gBACX,CAAC;gBACD,MAAM,CAAC,CAAC;YACV,CAAC;QACH,CAAC;QACD,MAAM,IAAI,mBAAW,CACnB,QAAQ,EACR,kCAAkC,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAC1E,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAED,gCAAgC;AAChC,mEAAmE;AACnE,kEAAkE;AAClE,wCAAwC;AAExC,SAAgB,OAAO,CAAC,CAAS,EAAE,GAAG,GAAG,GAAG;IAC1C,OAAO,CAAC,KAAK,EAAE,EAAE;QACf,IAAI,GAAG,GAAG,KAAK,CAAC;QAChB,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO,CAAC,GAAG,GAAG,EAAE,CAAC;YACf,IAAI,IAAgB,CAAC;YACrB,IAAI,CAAC;gBACH,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YAChB,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,GAAG,CAAC;YACb,CAAC;YACD,4EAA4E;YAC5E,yEAAyE;YACzE,gBAAgB;YAChB,IAAI,IAAI,KAAK,GAAG;gBAAE,OAAO,GAAG,CAAC;YAC7B,IAAI,IAAI,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC3B,GAAG,GAAG,IAAI,CAAC;YACX,CAAC,EAAE,CAAC;QACN,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;AACJ,CAAC;AAED,+BAA+B;AAC/B,gEAAgE;AAChE,oEAAoE;AAEpE,SAAgB,MAAM,CAAC,CAAS;IAC9B,OAAO,CAAC,KAAK,EAAE,EAAE;QACf,IAAI,CAAC;YACH,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC;QAClB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/tactic-dsl/index.d.ts

@@ -0,0 +1,39 @@
+import type { ProofState, Tactic } from './types';
+import { apply, assumption, caseAnalysis, destruct, exact, induction, intro, left as leftTactic, rewrite, rfl, right as rightTactic, simp, split, trivial, unfold } from './tactics';
+import { orElse, repeat_, seq, tryAlt } from './combinators';
+export type { Formula, Goal, ProofState, Tactic, TacticInvocation } from './types';
+export { TacticError, parseFormula, formulaToString, formulaEq, normalizeFormula } from './types';
+export type { DefDictionary } from './tactics';
+export { intro, exact, assumption, apply, rewrite, rfl, trivial, split, destruct, induction, caseAnalysis, unfold, simp, };
+export { leftTactic as left, rightTactic as right };
+export declare const case_: typeof caseAnalysis;
+export { seq, orElse, repeat_, tryAlt };
+export declare const T: {
+    intro: typeof intro;
+    exact: typeof exact;
+    assumption: typeof assumption;
+    apply: typeof apply;
+    rewrite: typeof rewrite;
+    rfl: typeof rfl;
+    trivial: typeof trivial;
+    split: typeof split;
+    left: typeof leftTactic;
+    right: typeof rightTactic;
+    destruct: typeof destruct;
+    induction: typeof induction;
+    caseAnalysis: typeof caseAnalysis;
+    case_: typeof caseAnalysis;
+    unfold: typeof unfold;
+    simp: typeof simp;
+    seq: typeof seq;
+    then: typeof seq;
+    orElse: typeof orElse;
+    repeat_: typeof repeat_;
+    tryAlt: typeof tryAlt;
+};
+export declare function startProof(goal: string, hyps?: Record<string, string>): ProofState;
+export declare function runTactic(state: ProofState, t: Tactic): ProofState;
+export declare function isProven(state: ProofState): boolean;
+export declare function summary(state: ProofState): string;
+export declare function _resetCounters(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/tactic-dsl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tactic-dsl/index.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAQ,UAAU,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACxD,OAAO,EAEL,KAAK,EACL,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,SAAS,EACT,KAAK,EACL,IAAI,IAAI,UAAU,EAClB,OAAO,EACP,GAAG,EACH,KAAK,IAAI,WAAW,EACpB,IAAI,EACJ,KAAK,EACL,OAAO,EACP,MAAM,EACP,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE7D,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAClG,YAAY,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/C,OAAO,EACL,KAAK,EACL,KAAK,EACL,UAAU,EACV,KAAK,EACL,OAAO,EACP,GAAG,EACH,OAAO,EACP,KAAK,EACL,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,MAAM,EACN,IAAI,GACL,CAAC;AACF,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,WAAW,IAAI,KAAK,EAAE,CAAC;AAGpD,eAAO,MAAM,KAAK,qBAAe,CAAC;AAIlC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AAKxC,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;CAwBb,CAAC;AAIF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,UAAU,CAkBtF;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAElE;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAEnD;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAcjD;AA6BD,wBAAgB,cAAc,IAAI,IAAI,CAGrC"}

package/dist/tactic-dsl/index.js

@@ -0,0 +1,162 @@
+"use strict";
+// ============================================================
+// Tactic DSL — entry point
+// ============================================================
+//
+// Pequeño DSL al estilo Lean/Coq para construir pruebas hacia atrás
+// (backwards) a partir de un goal. El motor:
+//   - mantiene una lista de goals abiertos
+//   - cada tactic transforma el goal frontal
+//   - los combinators (seq/orElse/repeat_/tryAlt) componen tactics
+//
+// La meta-prueba se considera completa cuando no quedan goals.
+// El estado lleva un `history` que registra invocaciones para que
+// el caller pueda renderizar el proof script reproducible.
+//
+// Nombres: la API original (Coq/Lean) usa `then` para encadenar
+// tactics. Por interop con vitest/ESM (un módulo ES con export
+// `then` se trata como thenable y bloquea el import), el combinador
+// se llama `seq` a nivel de export. Para mantener el lenguaje
+// Coq-like, exportamos un namespace `T` con `T.then = seq`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.T = exports.tryAlt = exports.repeat_ = exports.orElse = exports.seq = exports.case_ = exports.right = exports.left = exports.simp = exports.unfold = exports.caseAnalysis = exports.induction = exports.destruct = exports.split = exports.trivial = exports.rfl = exports.rewrite = exports.apply = exports.assumption = exports.exact = exports.intro = exports.normalizeFormula = exports.formulaEq = exports.formulaToString = exports.parseFormula = exports.TacticError = void 0;
+exports.startProof = startProof;
+exports.runTactic = runTactic;
+exports.isProven = isProven;
+exports.summary = summary;
+exports._resetCounters = _resetCounters;
+const types_1 = require("./types");
+const tactics_1 = require("./tactics");
+Object.defineProperty(exports, "apply", { enumerable: true, get: function () { return tactics_1.apply; } });
+Object.defineProperty(exports, "assumption", { enumerable: true, get: function () { return tactics_1.assumption; } });
+Object.defineProperty(exports, "caseAnalysis", { enumerable: true, get: function () { return tactics_1.caseAnalysis; } });
+Object.defineProperty(exports, "destruct", { enumerable: true, get: function () { return tactics_1.destruct; } });
+Object.defineProperty(exports, "exact", { enumerable: true, get: function () { return tactics_1.exact; } });
+Object.defineProperty(exports, "induction", { enumerable: true, get: function () { return tactics_1.induction; } });
+Object.defineProperty(exports, "intro", { enumerable: true, get: function () { return tactics_1.intro; } });
+Object.defineProperty(exports, "left", { enumerable: true, get: function () { return tactics_1.left; } });
+Object.defineProperty(exports, "rewrite", { enumerable: true, get: function () { return tactics_1.rewrite; } });
+Object.defineProperty(exports, "rfl", { enumerable: true, get: function () { return tactics_1.rfl; } });
+Object.defineProperty(exports, "right", { enumerable: true, get: function () { return tactics_1.right; } });
+Object.defineProperty(exports, "simp", { enumerable: true, get: function () { return tactics_1.simp; } });
+Object.defineProperty(exports, "split", { enumerable: true, get: function () { return tactics_1.split; } });
+Object.defineProperty(exports, "trivial", { enumerable: true, get: function () { return tactics_1.trivial; } });
+Object.defineProperty(exports, "unfold", { enumerable: true, get: function () { return tactics_1.unfold; } });
+const combinators_1 = require("./combinators");
+Object.defineProperty(exports, "orElse", { enumerable: true, get: function () { return combinators_1.orElse; } });
+Object.defineProperty(exports, "repeat_", { enumerable: true, get: function () { return combinators_1.repeat_; } });
+Object.defineProperty(exports, "seq", { enumerable: true, get: function () { return combinators_1.seq; } });
+Object.defineProperty(exports, "tryAlt", { enumerable: true, get: function () { return combinators_1.tryAlt; } });
+var types_2 = require("./types");
+Object.defineProperty(exports, "TacticError", { enumerable: true, get: function () { return types_2.TacticError; } });
+Object.defineProperty(exports, "parseFormula", { enumerable: true, get: function () { return types_2.parseFormula; } });
+Object.defineProperty(exports, "formulaToString", { enumerable: true, get: function () { return types_2.formulaToString; } });
+Object.defineProperty(exports, "formulaEq", { enumerable: true, get: function () { return types_2.formulaEq; } });
+Object.defineProperty(exports, "normalizeFormula", { enumerable: true, get: function () { return types_2.normalizeFormula; } });
+// Alias `case_` para `caseAnalysis` (case es palabra reservada en JS).
+exports.case_ = tactics_1.caseAnalysis;
+// Namespace `T` con todos los tactics y combinators. Aquí sí podemos
+// exponer `then` porque la propiedad vive sobre un objeto, no sobre
+// el module namespace.
+exports.T = {
+    // tactics
+    intro: tactics_1.intro,
+    exact: tactics_1.exact,
+    assumption: tactics_1.assumption,
+    apply: tactics_1.apply,
+    rewrite: tactics_1.rewrite,
+    rfl: tactics_1.rfl,
+    trivial: tactics_1.trivial,
+    split: tactics_1.split,
+    left: tactics_1.left,
+    right: tactics_1.right,
+    destruct: tactics_1.destruct,
+    induction: tactics_1.induction,
+    caseAnalysis: tactics_1.caseAnalysis,
+    case_: tactics_1.caseAnalysis,
+    unfold: tactics_1.unfold,
+    simp: tactics_1.simp,
+    // combinators
+    seq: combinators_1.seq,
+    then: combinators_1.seq, // alias Coq-style
+    orElse: // alias Coq-style
+    combinators_1.orElse,
+    repeat_: combinators_1.repeat_,
+    tryAlt: combinators_1.tryAlt,
+};
+let stateCounter = 0;
+function startProof(goal, hyps = {}) {
+    // sanity: el goal debe parsearse limpio.
+    (0, types_1.parseFormula)(goal);
+    stateCounter++;
+    const normalizedHyps = {};
+    for (const [n, t] of Object.entries(hyps)) {
+        normalizedHyps[n] = (0, types_1.normalizeFormula)(t);
+    }
+    const g = {
+        id: `g${stateCounter}`,
+        hyps: normalizedHyps,
+        concl: (0, types_1.normalizeFormula)(goal),
+    };
+    return {
+        goals: [g],
+        history: [],
+        done: false,
+    };
+}
+function runTactic(state, t) {
+    return t(state);
+}
+function isProven(state) {
+    return state.done && state.goals.length === 0;
+}
+function summary(state) {
+    if (state.done && state.goals.length === 0) {
+        const steps = state.history.map((h) => `  - ${h.tactic}(${formatArgs(h.args)})`);
+        return `Proof complete.\nHistory (${state.history.length} steps):\n${steps.join('\n')}`;
+    }
+    const open = state.goals
+        .map((g, idx) => {
+        const hyps = Object.entries(g.hyps)
+            .map(([n, t]) => `  ${n} : ${t}`)
+            .join('\n');
+        return `Goal ${idx + 1}/${state.goals.length} (${g.id}):\n${hyps}\n  ⊢ ${g.concl}`;
+    })
+        .join('\n\n');
+    return open;
+}
+function formatArgs(args) {
+    return args
+        .map((a) => {
+        if (a === null || a === undefined)
+            return '';
+        if (Array.isArray(a)) {
+            const items = a;
+            return `[${items.map((x) => formatScalar(x)).join(',')}]`;
+        }
+        return formatScalar(a);
+    })
+        .filter((s) => s.length > 0)
+        .join(', ');
+}
+function formatScalar(x) {
+    if (typeof x === 'string')
+        return x;
+    if (typeof x === 'number' || typeof x === 'boolean')
+        return String(x);
+    if (x === null || x === undefined)
+        return '';
+    // fallback seguro para evitar [object Object]
+    try {
+        return JSON.stringify(x);
+    }
+    catch {
+        return '';
+    }
+}
+// Test-only helper para resetear contadores y obtener determinismo.
+function _resetCounters() {
+    stateCounter = 0;
+    (0, tactics_1._resetGoalCounter)();
+}
+//# sourceMappingURL=index.js.map

package/dist/tactic-dsl/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tactic-dsl/index.ts"],"names":[],"mappings":"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"}

package/dist/tactic-dsl/tactics.d.ts

@@ -0,0 +1,21 @@
+import type { Tactic } from './types';
+export declare function _resetGoalCounter(): void;
+export declare function intro(name?: string): Tactic;
+export declare function exact(term: string): Tactic;
+export declare function assumption(): Tactic;
+export declare function apply(thm: string, args?: string[]): Tactic;
+export declare function rewrite(eq: string, dir?: 'left-to-right' | 'right-to-left'): Tactic;
+export declare function rfl(): Tactic;
+export declare function trivial(): Tactic;
+export declare function split(): Tactic;
+export declare function left(): Tactic;
+export declare function right(): Tactic;
+export declare function destruct(name: string): Tactic;
+export declare function induction(name: string): Tactic;
+export declare function caseAnalysis(name: string): Tactic;
+export interface DefDictionary {
+    [name: string]: string;
+}
+export declare function unfold(def: string, dict?: DefDictionary): Tactic;
+export declare function simp(): Tactic;
+//# sourceMappingURL=tactics.d.ts.map

package/dist/tactic-dsl/tactics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tactics.d.ts","sourceRoot":"","sources":["../../src/tactic-dsl/tactics.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAA6B,MAAM,EAAoB,MAAM,SAAS,CAAC;AASnF,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAwCD,wBAAgB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CA2B3C;AAaD,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiB1C;AAKD,wBAAgB,UAAU,IAAI,MAAM,CAcnC;AAeD,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAoD1D;AAMD,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,GAAG,GAAE,eAAe,GAAG,eAAiC,GACvD,MAAM,CA2BR;AAKD,wBAAgB,GAAG,IAAI,MAAM,CAa5B;AAKD,wBAAgB,OAAO,IAAI,MAAM,CAkBhC;AAKD,wBAAgB,KAAK,IAAI,MAAM,CAc9B;AAKD,wBAAgB,IAAI,IAAI,MAAM,CAW7B;AAED,wBAAgB,KAAK,IAAI,MAAM,CAW9B;AAOD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA0C7C;AASD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsC9C;AAeD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAQD,MAAM,WAAW,aAAa;IAC5B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,aAAkB,GAAG,MAAM,CAmBpE;AAWD,wBAAgB,IAAI,IAAI,MAAM,CAyB7B"}