@stevenvo780/st-lang 4.14.1 → 4.15.0

package/dist/reasoning/proof-mining/extractor.js

@@ -0,0 +1,170 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Extracción de sub-pruebas reutilizables
+// ============================================================
+//
+// Algoritmo:
+//
+//   1. Para cada proof P en el corpus, descomponer en sub-trees.
+//      Un sub-tree comienza en un paso s y abarca todos los pasos
+//      con depth > s.depth hasta que aparezca otro paso de depth
+//      ≤ s.depth (regreso al nivel del padre).
+//
+//   2. Para cada sub-tree, calcular una clave estructural (hash
+//      α-canónico): la secuencia de reglas + outputs normalizados a
+//      placeholders `?0`, `?1`, …
+//
+//   3. Agrupar sub-trees por clave. Los grupos con count ≥
+//      minReuseThreshold y size ≥ minSubtreeSize son candidatos
+//      a lemma.
+//
+// La descomposición es lineal en el tamaño del proof: cada paso
+// participa en O(1) sub-trees (el que arranca en él) — aunque cada
+// sub-tree puede tener O(size) pasos. Total: O(N · S) donde S es
+// el tamaño promedio del sub-tree (usualmente pequeño).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSubtrees = extractSubtrees;
+exports.subtreeKey = subtreeKey;
+exports.groupSubtrees = groupSubtrees;
+exports.extractAuxiliaryLemmas = extractAuxiliaryLemmas;
+const canonical_1 = require("../../runtime/theorem-cache/canonical");
+function genProofId(p, idx) {
+    return p.id ?? `proof-${idx}`;
+}
+/**
+ * Descompone un proof en sub-trees a partir de cada paso. El
+ * sub-tree con raíz en `i` incluye `steps[i]` y todos los
+ * descendientes consecutivos (depth > steps[i].depth) hasta que
+ * vuelve a aparecer un paso de depth ≤ steps[i].depth.
+ *
+ * Para steps[i] con depth d_i, el sub-tree es:
+ *   steps[i], steps[i+1], …, steps[j-1]
+ * donde j es el menor índice > i con steps[j].depth ≤ d_i (o
+ * length si no existe).
+ */
+function extractSubtrees(proof, proofId) {
+    const out = [];
+    const steps = proof.steps;
+    if (steps.length === 0)
+        return out;
+    // Cost prorrateado: cada paso aporta cost/length al sub-tree donde participa.
+    const perStepCost = proof.cost / Math.max(1, steps.length);
+    for (let i = 0; i < steps.length; i++) {
+        const root = steps[i];
+        if (root === undefined)
+            continue;
+        const rootDepth = root.depth;
+        let j = i + 1;
+        while (j < steps.length) {
+            const sj = steps[j];
+            if (sj === undefined)
+                break;
+            if (sj.depth <= rootDepth)
+                break;
+            j++;
+        }
+        const subSteps = steps.slice(i, j);
+        out.push({
+            proofId,
+            rootIndex: i,
+            steps: subSteps,
+            conclusion: root.output,
+            profile: proof.profile,
+            cost: perStepCost * subSteps.length,
+        });
+    }
+    return out;
+}
+/**
+ * Clave estructural canónica de un sub-tree.
+ *
+ * Combina: secuencia de reglas (por orden top-down) + diferencias
+ * relativas de depth (para reconstruir forma del árbol) + outputs
+ * normalizados α-canónicamente.
+ *
+ * El canónico depende del orden de aparición de los identificadores
+ * de cada output, lo que da un hash estable módulo renombrado de
+ * variables.
+ */
+function subtreeKey(sub) {
+    if (sub.steps.length === 0)
+        return 'empty';
+    const root = sub.steps[0];
+    if (root === undefined)
+        return 'empty';
+    const baseDepth = root.depth;
+    const parts = [];
+    // Renombrado coherente de identificadores a través de todos los outputs
+    // del sub-tree. Concatenamos con separador para que aparezcan en el orden
+    // correcto y un único pase de canonicalización los renombra de forma
+    // consistente.
+    const joined = sub.steps.map((s) => s.output).join(' ⫶ ');
+    const canon = (0, canonical_1.canonicalString)(joined);
+    const outputs = canon.split(' ⫶ ');
+    for (let i = 0; i < sub.steps.length; i++) {
+        const s = sub.steps[i];
+        if (s === undefined)
+            continue;
+        const out = outputs[i] ?? (0, canonical_1.canonicalString)(s.output);
+        parts.push(`${s.rule}@${s.depth - baseDepth}:${out}`);
+    }
+    return parts.join('|');
+}
+/**
+ * Agrupa sub-trees por clave estructural canónica.
+ */
+function groupSubtrees(candidates) {
+    const groups = new Map();
+    for (const c of candidates) {
+        const k = subtreeKey(c);
+        let g = groups.get(k);
+        if (g === undefined) {
+            g = {
+                key: k,
+                canonicalConclusion: (0, canonical_1.canonicalString)(c.conclusion),
+                members: [],
+            };
+            groups.set(k, g);
+        }
+        g.members.push(c);
+    }
+    return Array.from(groups.values());
+}
+/**
+ * Identifica sub-pruebas auxiliares en el corpus. Recibe un array
+ * de proofs, devuelve los grupos de sub-trees estructuralmente
+ * equivalentes que pasan los filtros (minReuseThreshold y
+ * minSubtreeSize).
+ *
+ * Esta función NO genera lemmas todavía — solo identifica los
+ * candidatos. `mineLemmas` los procesa, genera el statement y los
+ * persiste.
+ */
+function extractAuxiliaryLemmas(corpus, options) {
+    const minReuse = options?.minReuseThreshold ?? 2;
+    const minSize = options?.minSubtreeSize ?? 2;
+    const allSubtrees = [];
+    for (let i = 0; i < corpus.length; i++) {
+        const p = corpus[i];
+        if (p === undefined)
+            continue;
+        const id = genProofId(p, i);
+        for (const sub of extractSubtrees(p, id)) {
+            if (sub.steps.length < minSize)
+                continue;
+            allSubtrees.push(sub);
+        }
+    }
+    const groups = groupSubtrees(allSubtrees);
+    // Filtrar por umbral de reuso, contando proofs DISTINTOS (no
+    // múltiples ocurrencias dentro del mismo proof).
+    const filtered = [];
+    for (const g of groups) {
+        const distinctProofs = new Set(g.members.map((m) => m.proofId));
+        if (distinctProofs.size >= minReuse) {
+            filtered.push(g);
+        }
+    }
+    return filtered;
+}
+//# sourceMappingURL=extractor.js.map

package/dist/reasoning/proof-mining/extractor.js.map

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

package/dist/reasoning/proof-mining/generalizer.d.ts

@@ -0,0 +1,46 @@
+import type { Term, FreshSupply } from '../../runtime/anti-unification';
+/**
+ * Resultado de generalización: el statement (puede ser string con
+ * placeholders fresh), el conteo de variables abstractas
+ * introducidas y un flag de si la generalización es no-trivial
+ * (e.g. produjo placeholders).
+ */
+export interface GeneralizationResult {
+    statement: string;
+    abstractionLevel: number;
+    nonTrivial: boolean;
+}
+/**
+ * Generaliza una lista de instancias concretas vía anti-unification
+ * sobre términos. Útil cuando el caller ya parsea fórmulas a un AST
+ * `Term`.
+ */
+export declare function generalizeTerms(instances: Term[], freshSupply?: FreshSupply): GeneralizationResult;
+/**
+ * Generaliza una lista de fórmulas string. Tokeniza, alinea
+ * posicionalmente, y donde haya desacuerdo introduce un placeholder
+ * fresh. Si la tokenización produce arrays de distinta longitud, no
+ * intenta align: devuelve el primer string y nonTrivial = false.
+ *
+ * Tabla de desacuerdos: si el mismo par (a, b) reaparece, recibe el
+ * mismo placeholder (consistencia, propiedad LGG).
+ *
+ * Para igualar reservadas (operadores, paréntesis) en todas las
+ * instancias, esas posiciones se mantienen literales. Solo los
+ * tokens-identificador se generalizan.
+ */
+export declare function generalizeFormulas(instances: string[]): GeneralizationResult;
+/**
+ * Generaliza un grupo (lista de strings de conclusión, repetida
+ * tantas veces como instancias haya), opcionalmente capeando el
+ * abstractionLevel máximo.
+ *
+ * Si `preserveSemantic` está activo y la generalización no es
+ * instanciable de vuelta para cubrir todas las instancias, devuelve
+ * el literal de la primera instancia con abstractionLevel = 0.
+ */
+export declare function generalizeLemma(conclusions: string[], options?: {
+    maxAbstractionLevel?: number;
+    preserveSemantic?: boolean;
+}): GeneralizationResult;
+//# sourceMappingURL=generalizer.d.ts.map

package/dist/reasoning/proof-mining/generalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalizer.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/generalizer.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,oBAAoB,CAkBlG;AAmDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,oBAAoB,CA8D5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,CAAC,EAAE;IAAE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,GACrE,oBAAoB,CA2BtB"}

package/dist/reasoning/proof-mining/generalizer.js

@@ -0,0 +1,245 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Generalización de lemmas vía anti-unification
+// ============================================================
+//
+// Después de extraer sub-trees con la misma forma estructural (la
+// clave canónica los agrupa), queremos producir UN statement
+// generalizado que represente al grupo.
+//
+// Ejemplo concreto:
+//   - Proof A contiene sub-tree concluyendo  `P -> P`
+//   - Proof B contiene sub-tree concluyendo  `Q -> Q`
+//   - Proof C contiene sub-tree concluyendo  `R -> R`
+// El statement generalizado debería ser `?x -> ?x` (reflexividad
+// de la implicación, instancia del lemma “identity”).
+//
+// Para términos de primer orden (e.g. árboles AST), usamos el
+// algoritmo de Plotkin del módulo runtime/anti-unification.
+//
+// Para strings (caso conclusión sin parser), aproximamos el lgg
+// posicional: tokenizamos por whitespace + tokens-básicos, alineamos
+// el array y reemplazamos los desacuerdos por placeholders fresh.
+// Es una aproximación pragmática suficiente para conclusiones de
+// fórmulas; quien quiera lgg sobre árboles AST puede ir directo a
+// `antiUnifyMany` del runtime y feedearlo.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generalizeTerms = generalizeTerms;
+exports.generalizeFormulas = generalizeFormulas;
+exports.generalizeLemma = generalizeLemma;
+const anti_unification_1 = require("../../runtime/anti-unification");
+/**
+ * Generaliza una lista de instancias concretas vía anti-unification
+ * sobre términos. Útil cuando el caller ya parsea fórmulas a un AST
+ * `Term`.
+ */
+function generalizeTerms(instances, freshSupply) {
+    if (instances.length === 0) {
+        return { statement: '', abstractionLevel: 0, nonTrivial: false };
+    }
+    if (instances.length === 1) {
+        const t = instances[0];
+        if (t === undefined) {
+            return { statement: '', abstractionLevel: 0, nonTrivial: false };
+        }
+        return { statement: termToReadable(t), abstractionLevel: 0, nonTrivial: false };
+    }
+    const supply = freshSupply ?? (0, anti_unification_1.defaultFreshSupply)('?');
+    const result = (0, anti_unification_1.antiUnifyMany)(instances, supply);
+    return {
+        statement: termToReadable(result.generalization),
+        abstractionLevel: result.variables.length,
+        nonTrivial: result.variables.length > 0,
+    };
+}
+/**
+ * Render legible de un Term (compatible con la convención de
+ * lemma-synthesis: var/const → name, func → name(args)).
+ */
+function termToReadable(t) {
+    if (t.kind === 'var')
+        return t.name;
+    if (t.kind === 'const')
+        return t.name;
+    const args = t.args ?? [];
+    if (args.length === 0)
+        return t.name;
+    // Operadores binarios infijos
+    if (args.length === 2 && /^[+\-*/^∧∨↔→=<>≤≥&|]+$/.test(t.name)) {
+        const a0 = args[0];
+        const a1 = args[1];
+        if (a0 === undefined || a1 === undefined)
+            return t.name;
+        return `(${termToReadable(a0)} ${t.name} ${termToReadable(a1)})`;
+    }
+    return `${t.name}(${args.map(termToReadable).join(', ')})`;
+}
+// ── Generalización por tokens (sin parsear AST) ─────────────────
+/**
+ * Tokeniza una fórmula para alineamiento posicional. Mantiene los
+ * operadores como tokens propios.
+ */
+function tokenize(s) {
+    // Separa identificadores y operadores; ignora whitespace.
+    const out = [];
+    const re = /[A-Za-z_][A-Za-z0-9_]*|->|→|<->|↔|\(|\)|,|[¬∧∨∀∃⊤⊥=]|[^\sA-Za-z0-9_(),→↔¬∧∨∀∃⊤⊥=]+/g;
+    let m;
+    while ((m = re.exec(s)) !== null) {
+        out.push(m[0]);
+    }
+    return out;
+}
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED = new Set([
+    'not',
+    'and',
+    'or',
+    'implies',
+    'iff',
+    'forall',
+    'exists',
+    'true',
+    'false',
+]);
+/**
+ * Generaliza una lista de fórmulas string. Tokeniza, alinea
+ * posicionalmente, y donde haya desacuerdo introduce un placeholder
+ * fresh. Si la tokenización produce arrays de distinta longitud, no
+ * intenta align: devuelve el primer string y nonTrivial = false.
+ *
+ * Tabla de desacuerdos: si el mismo par (a, b) reaparece, recibe el
+ * mismo placeholder (consistencia, propiedad LGG).
+ *
+ * Para igualar reservadas (operadores, paréntesis) en todas las
+ * instancias, esas posiciones se mantienen literales. Solo los
+ * tokens-identificador se generalizan.
+ */
+function generalizeFormulas(instances) {
+    if (instances.length === 0) {
+        return { statement: '', abstractionLevel: 0, nonTrivial: false };
+    }
+    if (instances.length === 1) {
+        const s = instances[0];
+        return { statement: s ?? '', abstractionLevel: 0, nonTrivial: false };
+    }
+    const tokenized = instances.map(tokenize);
+    const len = tokenized[0]?.length ?? 0;
+    for (const t of tokenized) {
+        if (t.length !== len) {
+            // No alineable: caemos al canonical string como aproximación.
+            return {
+                statement: instances[0] ?? '',
+                abstractionLevel: 0,
+                nonTrivial: false,
+            };
+        }
+    }
+    // Tabla de desacuerdos: clave = tupla de tokens en cada lado en
+    // esa posición. Usamos JSON.stringify para clave estable.
+    const table = new Map();
+    let freshCounter = 0;
+    const fresh = () => `?${freshCounter++}`;
+    const variables = [];
+    const outTokens = [];
+    for (let i = 0; i < len; i++) {
+        const slice = tokenized.map((t) => t[i] ?? '');
+        const allEqual = slice.every((tok) => tok === slice[0]);
+        if (allEqual) {
+            outTokens.push(slice[0] ?? '');
+            continue;
+        }
+        // Solo abstraemos posiciones identificadoras (no operadores).
+        const allIdent = slice.every((tok) => IDENT_RE.test(tok) && !RESERVED.has(tok));
+        if (!allIdent) {
+            // Desacuerdo en operador o palabra reservada → no alineable.
+            return {
+                statement: instances[0] ?? '',
+                abstractionLevel: 0,
+                nonTrivial: false,
+            };
+        }
+        const key = JSON.stringify(slice);
+        let v = table.get(key);
+        if (v === undefined) {
+            v = fresh();
+            table.set(key, v);
+            variables.push(v);
+        }
+        outTokens.push(v);
+    }
+    return {
+        statement: outTokens.join(' '),
+        abstractionLevel: variables.length,
+        nonTrivial: variables.length > 0,
+    };
+}
+/**
+ * Generaliza un grupo (lista de strings de conclusión, repetida
+ * tantas veces como instancias haya), opcionalmente capeando el
+ * abstractionLevel máximo.
+ *
+ * Si `preserveSemantic` está activo y la generalización no es
+ * instanciable de vuelta para cubrir todas las instancias, devuelve
+ * el literal de la primera instancia con abstractionLevel = 0.
+ */
+function generalizeLemma(conclusions, options) {
+    const max = options?.maxAbstractionLevel ?? 3;
+    const preserve = options?.preserveSemantic ?? true;
+    const result = generalizeFormulas(conclusions);
+    if (result.abstractionLevel > max) {
+        // Si abstrajimos demasiado, retornamos el literal.
+        return {
+            statement: conclusions[0] ?? '',
+            abstractionLevel: 0,
+            nonTrivial: false,
+        };
+    }
+    if (preserve && result.nonTrivial) {
+        // Sanity check: verificar que el pattern instanciado en cada
+        // posición produce las conclusiones originales. Por construcción
+        // del algoritmo posicional, esto siempre se cumple si todos los
+        // tokens-identificador coinciden con los slots. Hacemos chequeo
+        // explícito para defender contra cambios futuros.
+        if (!verifyPatternCoversAll(result.statement, conclusions)) {
+            return {
+                statement: conclusions[0] ?? '',
+                abstractionLevel: 0,
+                nonTrivial: false,
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Verifica que el pattern (con placeholders `?0`, `?1`, …) sea
+ * instanciable para todas las conclusiones del grupo. Es un check
+ * defensivo: para el algoritmo posicional, esto siempre se cumple
+ * por construcción.
+ */
+function verifyPatternCoversAll(pattern, conclusions) {
+    const patTokens = tokenize(pattern);
+    for (const c of conclusions) {
+        const cTokens = tokenize(c);
+        if (cTokens.length !== patTokens.length)
+            return false;
+        const bindings = new Map();
+        for (let i = 0; i < patTokens.length; i++) {
+            const p = patTokens[i] ?? '';
+            const cc = cTokens[i] ?? '';
+            if (p.startsWith('?')) {
+                const prev = bindings.get(p);
+                if (prev === undefined) {
+                    bindings.set(p, cc);
+                }
+                else if (prev !== cc) {
+                    return false;
+                }
+            }
+            else if (p !== cc) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=generalizer.js.map

package/dist/reasoning/proof-mining/generalizer.js.map

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

package/dist/reasoning/proof-mining/index.d.ts

@@ -0,0 +1,62 @@
+import { TheoremCache } from '../../runtime/theorem-cache';
+import type { RankingWeights } from './ranker';
+import type { MinedLemma, MiningOptions, MiningResult, ProofTrace, UsageStats } from './types';
+export type { MinedLemma, MiningOptions, MiningResult, ProofStep, ProofTrace, UsageStats, } from './types';
+export type { SubtreeCandidate, SubtreeGroup } from './extractor';
+export type { GeneralizationResult } from './generalizer';
+export type { RankingWeights } from './ranker';
+export { extractSubtrees, groupSubtrees, subtreeKey, extractAuxiliaryLemmas, } from './extractor';
+export { generalizeLemma, generalizeFormulas, generalizeTerms, } from './generalizer';
+export { rankLemmas, scoreLemma, topK } from './ranker';
+export { persistLemmas, recoverLemmas, recoverLemmaFromCache, MINED_LEMMA_PROVER, } from './persistence';
+export { computeStats, statsToString } from './statistics';
+/**
+ * Mina lemmas del corpus de proofs. Devuelve los lemmas ordenados
+ * por score descendente + stats agregadas.
+ *
+ * Esta es la entrada principal del módulo. No persiste por defecto;
+ * para meter al cache, pasar `cache` o usar `ProofMiner`.
+ */
+export declare function mineLemmas(corpus: ProofTrace[], options?: MiningOptions & {
+    weights?: RankingWeights;
+    cache?: TheoremCache;
+}): MiningResult;
+/**
+ * `ProofMiner` es una clase fachada con estado interno: acumula
+ * lemmas a través de múltiples corpus, los persiste en un cache
+ * común, y expone consultas.
+ */
+export declare class ProofMiner {
+    private readonly cache;
+    private readonly options;
+    private readonly weights;
+    private readonly seen;
+    private totalProofsAnalyzed;
+    private totalCandidatesFound;
+    constructor(opts?: MiningOptions & {
+        weights?: RankingWeights;
+        cache?: TheoremCache;
+    });
+    /**
+     * Procesa un corpus de proofs y acumula los lemmas en estado.
+     * Lemmas con el mismo `id` se mergean: usageCount += new, savings
+     * += new, sourceProofs se unifican.
+     */
+    mine(corpus: ProofTrace[]): MiningResult;
+    /**
+     * Devuelve los lemmas acumulados, rankeados.
+     */
+    all(): MinedLemma[];
+    /**
+     * Top-k del catálogo acumulado.
+     */
+    top(k: number): MinedLemma[];
+    /**
+     * Stats agregadas.
+     */
+    stats(): UsageStats;
+    /** Cache subyacente (lectura). */
+    getCache(): TheoremCache;
+    clear(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/reasoning/proof-mining/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,YAAY,EAEZ,UAAU,EACV,UAAU,EACX,MAAM,SAAS,CAAC;AAIjB,YAAY,EACV,UAAU,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EACL,eAAe,EACf,aAAa,EACb,UAAU,EACV,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,eAAe,GAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EACL,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAsF3D;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,CAAC,EAAE,aAAa,GAAG;IAAE,OAAO,CAAC,EAAE,cAAc,CAAC;IAAC,KAAK,CAAC,EAAE,YAAY,CAAA;CAAE,GAC3E,YAAY,CA0Bd;AAID;;;;GAIG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAiC;IACtD,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,oBAAoB,CAAK;gBAErB,IAAI,CAAC,EAAE,aAAa,GAAG;QAAE,OAAO,CAAC,EAAE,cAAc,CAAC;QAAC,KAAK,CAAC,EAAE,YAAY,CAAA;KAAE;IAMrF;;;;OAIG;IACH,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,YAAY;IAkCxC;;OAEG;IACH,GAAG,IAAI,UAAU,EAAE;IAInB;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE;IAI5B;;OAEG;IACH,KAAK,IAAI,UAAU;IAQnB,kCAAkC;IAClC,QAAQ,IAAI,YAAY;IAIxB,KAAK,IAAI,IAAI;CAKd"}