@stevenvo780/st-lang 4.1.0 → 4.3.0

package/dist/belief-revision/sat.js

@@ -0,0 +1,90 @@
+"use strict";
+// ============================================================
+// ST Belief Revision — Mini SAT por enumeración (clásico propositional)
+// ============================================================
+//
+// Para las fórmulas y belief sets manejados por AGM, el número de átomos
+// típico es pequeño (< 20). Usamos enumeración 2^n directa: simple, exacto
+// y suficiente para tests y uso pedagógico. Para casos grandes el caller
+// debería usar el SAT solver de st-lang (CDCL).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalFormula = evalFormula;
+exports.isSatisfiable = isSatisfiable;
+exports.entailsFormula = entailsFormula;
+exports.areEquivalent = areEquivalent;
+const parser_1 = require("./parser");
+/** Evalúa una fórmula bajo una valuación clásica. */
+function evalFormula(f, v) {
+    switch (f.kind) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        case 'atom':
+            return v[f.name] ?? false;
+        case 'not':
+            return !evalFormula(f.arg, v);
+        case 'and':
+            return evalFormula(f.left, v) && evalFormula(f.right, v);
+        case 'or':
+            return evalFormula(f.left, v) || evalFormula(f.right, v);
+        case 'implies':
+            return !evalFormula(f.left, v) || evalFormula(f.right, v);
+        case 'iff':
+            return evalFormula(f.left, v) === evalFormula(f.right, v);
+    }
+}
+/**
+ * Enumera todas las valuaciones sobre `atoms` y aplica `predicate`.
+ * Retorna `true` apenas alguna satisface (early exit).
+ */
+function existsValuation(atoms, predicate) {
+    const n = atoms.length;
+    const total = 1 << n;
+    for (let mask = 0; mask < total; mask += 1) {
+        const v = {};
+        for (let i = 0; i < n; i += 1) {
+            const atom = atoms[i];
+            if (atom !== undefined) {
+                v[atom] = ((mask >> i) & 1) === 1;
+            }
+        }
+        if (predicate(v))
+            return true;
+    }
+    return false;
+}
+/**
+ * ¿Es satisfactible la conjunción de `formulas`?
+ * Conjunto vacío → trivialmente satisfactible.
+ */
+function isSatisfiable(formulas) {
+    if (formulas.length === 0)
+        return true;
+    const atoms = new Set();
+    for (const f of formulas)
+        (0, parser_1.collectAtoms)(f, atoms);
+    const atomList = Array.from(atoms);
+    // Caso degenerado: ninguna variable proposicional, evaluar con valuación vacía.
+    if (atomList.length === 0) {
+        return formulas.every((f) => evalFormula(f, {}));
+    }
+    return existsValuation(atomList, (v) => formulas.every((f) => evalFormula(f, v)));
+}
+/**
+ * ¿K (conjunción de fórmulas) implica φ?
+ * Equivalente a: K ∧ ¬φ es insatisfactible.
+ */
+function entailsFormula(K, phi) {
+    const negated = { kind: 'not', arg: phi };
+    return !isSatisfiable([...K, negated]);
+}
+/**
+ * ¿Son φ y ψ lógicamente equivalentes? (φ ↔ ψ es tautología)
+ */
+function areEquivalent(a, b) {
+    const iff = { kind: 'iff', left: a, right: b };
+    // Es equivalente sii ¬(a↔b) es insatisfactible.
+    return !isSatisfiable([{ kind: 'not', arg: iff }]);
+}
+//# sourceMappingURL=sat.js.map

package/dist/belief-revision/sat.js.map

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

package/dist/belief-revision/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Un belief set K: conjunto de fórmulas (cadenas) más una caché opcional
+ * de consistencia. La caché es informativa: las operaciones siempre
+ * recalculan la consistencia sobre las fórmulas reales.
+ */
+export interface BeliefSet {
+    formulas: Set<string>;
+    consistent?: boolean;
+}
+/**
+ * Orden parcial de "entrenchment" (arraigamiento epistémico).
+ * Mapea fórmula → nivel; mayor número = creencia más arraigada
+ * (más difícil de remover). Fórmulas no presentes en el mapa se
+ * consideran al nivel 0 (default, fácilmente removibles).
+ */
+export type PartialOrder = Map<string, number>;
+/**
+ * Representación interna de una fórmula proposicional:
+ * - {kind: 'atom', name: 'p'}
+ * - {kind: 'not', arg}
+ * - {kind: 'and'|'or'|'implies'|'iff', left, right}
+ * - {kind: 'true'} | {kind: 'false'}
+ */
+export type PropFormula = {
+    kind: 'true';
+} | {
+    kind: 'false';
+} | {
+    kind: 'atom';
+    name: string;
+} | {
+    kind: 'not';
+    arg: PropFormula;
+} | {
+    kind: 'and';
+    left: PropFormula;
+    right: PropFormula;
+} | {
+    kind: 'or';
+    left: PropFormula;
+    right: PropFormula;
+} | {
+    kind: 'implies';
+    left: PropFormula;
+    right: PropFormula;
+} | {
+    kind: 'iff';
+    left: PropFormula;
+    right: PropFormula;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/belief-revision/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/belief-revision/types.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,CAAC"}

package/dist/belief-revision/types.js

@@ -0,0 +1,10 @@
+"use strict";
+// ============================================================
+// ST Belief Revision — Tipos AGM
+// ============================================================
+//
+// Implementa operadores AGM (Alchourrón-Gärdenfors-Makinson) sobre
+// belief sets propositionales. Las creencias se almacenan como cadenas
+// (forma sintáctica) pero la lógica subyacente es clásica propositional.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/belief-revision/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/belief-revision/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iCAAiC;AACjC,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,uEAAuE;AACvE,yEAAyE"}

package/dist/curry-howard/index.d.ts

@@ -0,0 +1,7 @@
+export type { PropType, LambdaTerm, ProofTree, ProofRule, Context } from './types';
+export { atom, arrow, product, sum, bottom, vr, app, abs, pair, fst, snd, inl, inr, cse, absurd, eqType, typeToString, termToString, } from './types';
+export { inferType, isInferError } from './infer';
+export type { InferResult } from './infer';
+export { reduceBeta, normalize, isNormal, freeVars, substituteTerm } from './reduce';
+export { termToProof, proofToTerm, proofIsConsistent, ProofConversionError } from './proof';
+//# sourceMappingURL=index.d.ts.map

package/dist/curry-howard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/curry-howard/index.ts"],"names":[],"mappings":"AAUA,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACnF,OAAO,EACL,IAAI,EACJ,KAAK,EACL,OAAO,EACP,GAAG,EACH,MAAM,EACN,EAAE,EACF,GAAG,EACH,GAAG,EACH,IAAI,EACJ,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,MAAM,EACN,YAAY,EACZ,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAClD,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAErF,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC"}

package/dist/curry-howard/index.js

@@ -0,0 +1,46 @@
+"use strict";
+// ============================================================
+// ST Curry-Howard — Punto de entrada público
+// ============================================================
+//
+// Correspondencia Curry-Howard sobre λ-cálculo simplemente tipado:
+//   - λ-terms anotados con tipos = pruebas en deducción natural
+//   - inferType: λ-term → proposición probada
+//   - termToProof / proofToTerm: conversión bidireccional
+//   - reduceBeta / normalize: normalización (β + proyecciones + case)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofConversionError = exports.proofIsConsistent = exports.proofToTerm = exports.termToProof = exports.substituteTerm = exports.freeVars = exports.isNormal = exports.normalize = exports.reduceBeta = exports.isInferError = exports.inferType = exports.termToString = exports.typeToString = exports.eqType = exports.absurd = exports.cse = exports.inr = exports.inl = exports.snd = exports.fst = exports.pair = exports.abs = exports.app = exports.vr = exports.bottom = exports.sum = exports.product = exports.arrow = exports.atom = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "atom", { enumerable: true, get: function () { return types_1.atom; } });
+Object.defineProperty(exports, "arrow", { enumerable: true, get: function () { return types_1.arrow; } });
+Object.defineProperty(exports, "product", { enumerable: true, get: function () { return types_1.product; } });
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return types_1.sum; } });
+Object.defineProperty(exports, "bottom", { enumerable: true, get: function () { return types_1.bottom; } });
+Object.defineProperty(exports, "vr", { enumerable: true, get: function () { return types_1.vr; } });
+Object.defineProperty(exports, "app", { enumerable: true, get: function () { return types_1.app; } });
+Object.defineProperty(exports, "abs", { enumerable: true, get: function () { return types_1.abs; } });
+Object.defineProperty(exports, "pair", { enumerable: true, get: function () { return types_1.pair; } });
+Object.defineProperty(exports, "fst", { enumerable: true, get: function () { return types_1.fst; } });
+Object.defineProperty(exports, "snd", { enumerable: true, get: function () { return types_1.snd; } });
+Object.defineProperty(exports, "inl", { enumerable: true, get: function () { return types_1.inl; } });
+Object.defineProperty(exports, "inr", { enumerable: true, get: function () { return types_1.inr; } });
+Object.defineProperty(exports, "cse", { enumerable: true, get: function () { return types_1.cse; } });
+Object.defineProperty(exports, "absurd", { enumerable: true, get: function () { return types_1.absurd; } });
+Object.defineProperty(exports, "eqType", { enumerable: true, get: function () { return types_1.eqType; } });
+Object.defineProperty(exports, "typeToString", { enumerable: true, get: function () { return types_1.typeToString; } });
+Object.defineProperty(exports, "termToString", { enumerable: true, get: function () { return types_1.termToString; } });
+var infer_1 = require("./infer");
+Object.defineProperty(exports, "inferType", { enumerable: true, get: function () { return infer_1.inferType; } });
+Object.defineProperty(exports, "isInferError", { enumerable: true, get: function () { return infer_1.isInferError; } });
+var reduce_1 = require("./reduce");
+Object.defineProperty(exports, "reduceBeta", { enumerable: true, get: function () { return reduce_1.reduceBeta; } });
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return reduce_1.normalize; } });
+Object.defineProperty(exports, "isNormal", { enumerable: true, get: function () { return reduce_1.isNormal; } });
+Object.defineProperty(exports, "freeVars", { enumerable: true, get: function () { return reduce_1.freeVars; } });
+Object.defineProperty(exports, "substituteTerm", { enumerable: true, get: function () { return reduce_1.substituteTerm; } });
+var proof_1 = require("./proof");
+Object.defineProperty(exports, "termToProof", { enumerable: true, get: function () { return proof_1.termToProof; } });
+Object.defineProperty(exports, "proofToTerm", { enumerable: true, get: function () { return proof_1.proofToTerm; } });
+Object.defineProperty(exports, "proofIsConsistent", { enumerable: true, get: function () { return proof_1.proofIsConsistent; } });
+Object.defineProperty(exports, "ProofConversionError", { enumerable: true, get: function () { return proof_1.ProofConversionError; } });
+//# sourceMappingURL=index.js.map

package/dist/curry-howard/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/curry-howard/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,6CAA6C;AAC7C,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,gEAAgE;AAChE,8CAA8C;AAC9C,0DAA0D;AAC1D,sEAAsE;;;AAGtE,iCAmBiB;AAlBf,6FAAA,IAAI,OAAA;AACJ,8FAAA,KAAK,OAAA;AACL,gGAAA,OAAO,OAAA;AACP,4FAAA,GAAG,OAAA;AACH,+FAAA,MAAM,OAAA;AACN,2FAAA,EAAE,OAAA;AACF,4FAAA,GAAG,OAAA;AACH,4FAAA,GAAG,OAAA;AACH,6FAAA,IAAI,OAAA;AACJ,4FAAA,GAAG,OAAA;AACH,4FAAA,GAAG,OAAA;AACH,4FAAA,GAAG,OAAA;AACH,4FAAA,GAAG,OAAA;AACH,4FAAA,GAAG,OAAA;AACH,+FAAA,MAAM,OAAA;AACN,+FAAA,MAAM,OAAA;AACN,qGAAA,YAAY,OAAA;AACZ,qGAAA,YAAY,OAAA;AAGd,iCAAkD;AAAzC,kGAAA,SAAS,OAAA;AAAE,qGAAA,YAAY,OAAA;AAGhC,mCAAqF;AAA5E,oGAAA,UAAU,OAAA;AAAE,mGAAA,SAAS,OAAA;AAAE,kGAAA,QAAQ,OAAA;AAAE,kGAAA,QAAQ,OAAA;AAAE,wGAAA,cAAc,OAAA;AAElE,iCAA4F;AAAnF,oGAAA,WAAW,OAAA;AAAE,oGAAA,WAAW,OAAA;AAAE,0GAAA,iBAAiB,OAAA;AAAE,6GAAA,oBAAoB,OAAA"}

package/dist/curry-howard/infer.d.ts

@@ -0,0 +1,9 @@
+import type { Context, LambdaTerm, PropType } from './types';
+export type InferResult = PropType | {
+    error: string;
+};
+export declare function inferType(term: LambdaTerm, ctx?: Context): InferResult;
+export declare function isInferError(r: InferResult): r is {
+    error: string;
+};
+//# sourceMappingURL=infer.d.ts.map

package/dist/curry-howard/infer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.d.ts","sourceRoot":"","sources":["../../src/curry-howard/infer.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG7D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,GAAE,OAAY,GAAG,WAAW,CAE1E;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,IAAI;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAEnE"}

package/dist/curry-howard/infer.js

@@ -0,0 +1,129 @@
+"use strict";
+// ============================================================
+// Curry-Howard — Type inference (checking) para λ-terms anotados
+// ============================================================
+//
+// El λ-cálculo simplemente tipado con anotaciones en el binder
+// admite type-checking directo (no requiere Hindley-Milner): cada
+// abstracción declara el tipo de su parámetro, así que el tipo
+// del cuerpo se obtiene recursivamente.
+//
+// Devuelve `{ error }` en lugar de lanzar para que sea fácil
+// componer en tests y herramientas didácticas.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferType = inferType;
+exports.isInferError = isInferError;
+const types_1 = require("./types");
+function inferType(term, ctx = {}) {
+    return inferInternal(term, ctx);
+}
+function isInferError(r) {
+    return typeof r === 'object' && r !== null && 'error' in r;
+}
+function inferInternal(term, ctx) {
+    switch (term.kind) {
+        case 'var': {
+            const t = ctx[term.name];
+            if (!t)
+                return { error: `variable libre sin tipo en contexto: '${term.name}'` };
+            return t;
+        }
+        case 'abs': {
+            const newCtx = { ...ctx, [term.param]: term.paramType };
+            const bodyType = inferInternal(term.body, newCtx);
+            if (isInferError(bodyType))
+                return bodyType;
+            return { kind: 'arrow', from: term.paramType, to: bodyType };
+        }
+        case 'app': {
+            const fnT = inferInternal(term.fn, ctx);
+            if (isInferError(fnT))
+                return fnT;
+            if (fnT.kind !== 'arrow') {
+                return {
+                    error: `aplicación requiere función A→B, encontré: ${(0, types_1.typeToString)(fnT)}`,
+                };
+            }
+            const argT = inferInternal(term.arg, ctx);
+            if (isInferError(argT))
+                return argT;
+            if (!(0, types_1.eqType)(fnT.from, argT)) {
+                return {
+                    error: `tipo de argumento no coincide: esperaba ${(0, types_1.typeToString)(fnT.from)}, obtuve ${(0, types_1.typeToString)(argT)}`,
+                };
+            }
+            return fnT.to;
+        }
+        case 'pair': {
+            const a = inferInternal(term.fst, ctx);
+            if (isInferError(a))
+                return a;
+            const b = inferInternal(term.snd, ctx);
+            if (isInferError(b))
+                return b;
+            return { kind: 'product', left: a, right: b };
+        }
+        case 'fst': {
+            const p = inferInternal(term.pair, ctx);
+            if (isInferError(p))
+                return p;
+            if (p.kind !== 'product') {
+                return { error: `fst espera A∧B, recibí: ${(0, types_1.typeToString)(p)}` };
+            }
+            return p.left;
+        }
+        case 'snd': {
+            const p = inferInternal(term.pair, ctx);
+            if (isInferError(p))
+                return p;
+            if (p.kind !== 'product') {
+                return { error: `snd espera A∧B, recibí: ${(0, types_1.typeToString)(p)}` };
+            }
+            return p.right;
+        }
+        case 'inl': {
+            const l = inferInternal(term.left, ctx);
+            if (isInferError(l))
+                return l;
+            return { kind: 'sum', left: l, right: term.rightType };
+        }
+        case 'inr': {
+            const r = inferInternal(term.right, ctx);
+            if (isInferError(r))
+                return r;
+            return { kind: 'sum', left: term.leftType, right: r };
+        }
+        case 'case': {
+            const sT = inferInternal(term.scrutinee, ctx);
+            if (isInferError(sT))
+                return sT;
+            if (sT.kind !== 'sum') {
+                return { error: `case espera A∨B, recibí: ${(0, types_1.typeToString)(sT)}` };
+            }
+            const leftCtx = { ...ctx, [term.leftBind]: sT.left };
+            const lT = inferInternal(term.leftBody, leftCtx);
+            if (isInferError(lT))
+                return lT;
+            const rightCtx = { ...ctx, [term.rightBind]: sT.right };
+            const rT = inferInternal(term.rightBody, rightCtx);
+            if (isInferError(rT))
+                return rT;
+            if (!(0, types_1.eqType)(lT, rT)) {
+                return {
+                    error: `ramas de case con tipos distintos: ${(0, types_1.typeToString)(lT)} vs ${(0, types_1.typeToString)(rT)}`,
+                };
+            }
+            return lT;
+        }
+        case 'absurd': {
+            const p = inferInternal(term.proofOfFalse, ctx);
+            if (isInferError(p))
+                return p;
+            if (p.kind !== 'bottom') {
+                return { error: `absurd espera ⊥, recibí: ${(0, types_1.typeToString)(p)}` };
+            }
+            return term.resultType;
+        }
+    }
+}
+//# sourceMappingURL=infer.js.map

package/dist/curry-howard/infer.js.map

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

package/dist/curry-howard/proof.d.ts

@@ -0,0 +1,7 @@
+import type { Context, LambdaTerm, ProofTree } from './types';
+export declare class ProofConversionError extends Error {
+}
+export declare function termToProof(term: LambdaTerm, ctx?: Context): ProofTree;
+export declare function proofToTerm(proof: ProofTree): LambdaTerm;
+export declare function proofIsConsistent(proof: ProofTree): boolean;
+//# sourceMappingURL=proof.d.ts.map

package/dist/curry-howard/proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../src/curry-howard/proof.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAG9D,qBAAa,oBAAqB,SAAQ,KAAK;CAAG;AAGlD,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,GAAE,OAAY,GAAG,SAAS,CAE1E;AAwHD,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAkFxD;AAID,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAa3D"}