@stevenvo780/st-lang 4.3.0 → 4.5.0

package/dist/combinators-ski/reduce.js

@@ -0,0 +1,118 @@
+"use strict";
+// ============================================================
+// SKI combinatory logic — Reducción
+// ============================================================
+//
+// Reglas (weak reduction, leftmost-outermost):
+//   I x      → x
+//   K x y    → x          (descarta `y` aunque éste tenga redex propios)
+//   S x y z  → x z (y z)
+//
+// `reduceStep` aplica un único paso si encuentra un redex en la
+// cabeza o, si no, baja por las ramas siguiendo orden
+// leftmost-outermost. Como no hay binders ni captura, no se requiere
+// renombrar; la sustitución es pegado físico de subárboles.
+//
+// La forma normal SKI puede no existir (e.g. términos divergentes
+// equivalentes a Ω), por lo que `normalize` recibe `maxSteps`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceStep = reduceStep;
+exports.normalize = normalize;
+exports.isNormalForm = isNormalForm;
+// Devuelve el término reducido en UN paso, o `null` si no hay redex.
+function reduceStep(t) {
+    // Intenta primero un paso en la posición de cabeza.
+    const head = reduceHead(t);
+    if (head !== null)
+        return head;
+    // Si no hay redex en cabeza, baja recursivamente.
+    switch (t.kind) {
+        case 'app': {
+            const fn2 = reduceStep(t.fn);
+            if (fn2 !== null)
+                return { kind: 'app', fn: fn2, arg: t.arg };
+            const arg2 = reduceStep(t.arg);
+            if (arg2 !== null)
+                return { kind: 'app', fn: t.fn, arg: arg2 };
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+// Intenta una reducción en la posición de cabeza del término.
+// Devuelve `null` si no hay redex de cabeza.
+function reduceHead(t) {
+    if (t.kind !== 'app')
+        return null;
+    // Junta la cabeza (combinador o variable) con sus argumentos
+    // recorridos por la espina izquierda.
+    const spine = [];
+    let cursor = t;
+    while (cursor.kind === 'app') {
+        spine.unshift(cursor.arg);
+        cursor = cursor.fn;
+    }
+    // `cursor` es la cabeza definitiva (S/K/I/var); `spine` son los args
+    // aplicados de izquierda a derecha.
+    switch (cursor.kind) {
+        case 'I': {
+            const x = spine[0];
+            if (x === undefined)
+                return null;
+            // I x rest... → x rest...
+            return rebuild(x, spine.slice(1));
+        }
+        case 'K': {
+            const x = spine[0];
+            const y = spine[1];
+            if (x === undefined || y === undefined)
+                return null;
+            // K x y rest... → x rest...     (y se descarta)
+            return rebuild(x, spine.slice(2));
+        }
+        case 'S': {
+            const x = spine[0];
+            const y = spine[1];
+            const z = spine[2];
+            if (x === undefined || y === undefined || z === undefined)
+                return null;
+            // S x y z rest... → (x z (y z)) rest...
+            const reduced = {
+                kind: 'app',
+                fn: { kind: 'app', fn: x, arg: z },
+                arg: { kind: 'app', fn: y, arg: z },
+            };
+            return rebuild(reduced, spine.slice(3));
+        }
+        default:
+            return null;
+    }
+}
+// Reconstruye `head arg0 arg1 ...` como aplicación asociativa a la izquierda.
+function rebuild(head, args) {
+    let acc = head;
+    for (const a of args) {
+        acc = { kind: 'app', fn: acc, arg: a };
+    }
+    return acc;
+}
+// Itera reducciones hasta forma normal o agotar `maxSteps`.
+// `terminated=true` significa que no quedan redex (forma normal SKI);
+// `false` indica que se alcanzó el cap (típico para términos divergentes).
+function normalize(t, maxSteps = 1000) {
+    let current = t;
+    let steps = 0;
+    for (; steps < maxSteps; steps += 1) {
+        const next = reduceStep(current);
+        if (next === null)
+            return { result: current, steps, terminated: true };
+        current = next;
+    }
+    return { result: current, steps, terminated: false };
+}
+// ¿No hay más redex aplicable?
+function isNormalForm(t) {
+    return reduceStep(t) === null;
+}
+//# sourceMappingURL=reduce.js.map

package/dist/combinators-ski/reduce.js.map

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

package/dist/combinators-ski/types.d.ts

@@ -0,0 +1,23 @@
+export type CTerm = {
+    kind: 'S';
+} | {
+    kind: 'K';
+} | {
+    kind: 'I';
+} | {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'app';
+    fn: CTerm;
+    arg: CTerm;
+};
+export declare const S: () => CTerm;
+export declare const K: () => CTerm;
+export declare const I: () => CTerm;
+export declare const cvar: (name: string) => CTerm;
+export declare function app(...ts: CTerm[]): CTerm;
+export declare function ctermEq(a: CTerm, b: CTerm): boolean;
+export declare function termToString(t: CTerm): string;
+export declare function freeVars(t: CTerm): Set<string>;
+//# sourceMappingURL=types.d.ts.map

package/dist/combinators-ski/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/combinators-ski/types.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,KAAK,GACb;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,KAAK,CAAA;CAAE,CAAC;AAG3C,eAAO,MAAM,CAAC,QAAO,KAAwB,CAAC;AAC9C,eAAO,MAAM,CAAC,QAAO,KAAwB,CAAC;AAC9C,eAAO,MAAM,CAAC,QAAO,KAAwB,CAAC;AAC9C,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,KAAG,KAAgC,CAAC;AAIrE,wBAAgB,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,KAAK,CAYzC;AAGD,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAcnD;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAgB7C;AAGD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CAI9C"}

package/dist/combinators-ski/types.js

@@ -0,0 +1,102 @@
+"use strict";
+// ============================================================
+// SKI combinatory logic — Términos y constructores
+// ============================================================
+//
+// Sistema base de combinadores S, K, I (Schönfinkel / Curry). Es
+// Turing-completo y equivalente al λ-cálculo, pero sin variables
+// ligadas: toda función se construye combinando S, K, I y variables
+// libres mediante aplicación. Las λ-abstracciones se "eliminan"
+// vía bracket abstraction (ver `abstract.ts`).
+//
+// Reglas de reducción:
+//   I x      → x
+//   K x y    → x
+//   S x y z  → x z (y z)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cvar = exports.I = exports.K = exports.S = void 0;
+exports.app = app;
+exports.ctermEq = ctermEq;
+exports.termToString = termToString;
+exports.freeVars = freeVars;
+// ---------- Constructores convenientes ----------
+const S = () => ({ kind: 'S' });
+exports.S = S;
+const K = () => ({ kind: 'K' });
+exports.K = K;
+const I = () => ({ kind: 'I' });
+exports.I = I;
+const cvar = (name) => ({ kind: 'var', name });
+exports.cvar = cvar;
+// Aplicación n-aria asociativa a la izquierda: app(f, a, b, c) = ((f a) b) c.
+// Con un solo argumento devuelve el término tal cual; sin argumentos lanza.
+function app(...ts) {
+    const head = ts[0];
+    if (head === undefined) {
+        throw new Error('app() requiere al menos un término');
+    }
+    let acc = head;
+    for (let i = 1; i < ts.length; i += 1) {
+        const next = ts[i];
+        if (next === undefined)
+            break;
+        acc = { kind: 'app', fn: acc, arg: next };
+    }
+    return acc;
+}
+// Igualdad estructural (no hay alpha — no hay binders).
+function ctermEq(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'S':
+        case 'K':
+        case 'I':
+            return true;
+        case 'var':
+            return a.name === b.name;
+        case 'app': {
+            const bb = b;
+            return ctermEq(a.fn, bb.fn) && ctermEq(a.arg, bb.arg);
+        }
+    }
+}
+// Pretty-printer. Aplicación asociativa a la izquierda: agrupa con
+// paréntesis sólo cuando el argumento es a su vez una aplicación.
+function termToString(t) {
+    switch (t.kind) {
+        case 'S':
+            return 'S';
+        case 'K':
+            return 'K';
+        case 'I':
+            return 'I';
+        case 'var':
+            return t.name;
+        case 'app': {
+            const fn = termToString(t.fn);
+            const arg = t.arg.kind === 'app' ? `(${termToString(t.arg)})` : termToString(t.arg);
+            return `${fn} ${arg}`;
+        }
+    }
+}
+// Variables libres del término (no hay ligadas en SKI puro).
+function freeVars(t) {
+    const acc = new Set();
+    collect(t, acc);
+    return acc;
+}
+function collect(t, acc) {
+    switch (t.kind) {
+        case 'var':
+            acc.add(t.name);
+            return;
+        case 'app':
+            collect(t.fn, acc);
+            collect(t.arg, acc);
+            return;
+        default:
+            return;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/combinators-ski/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/combinators-ski/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,iEAAiE;AACjE,iEAAiE;AACjE,oEAAoE;AACpE,gEAAgE;AAChE,+CAA+C;AAC/C,EAAE;AACF,uBAAuB;AACvB,iBAAiB;AACjB,iBAAiB;AACjB,yBAAyB;;;AAiBzB,kBAYC;AAGD,0BAcC;AAID,oCAgBC;AAGD,4BAIC;AAhED,mDAAmD;AAC5C,MAAM,CAAC,GAAG,GAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;AAAjC,QAAA,CAAC,KAAgC;AACvC,MAAM,CAAC,GAAG,GAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;AAAjC,QAAA,CAAC,KAAgC;AACvC,MAAM,CAAC,GAAG,GAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;AAAjC,QAAA,CAAC,KAAgC;AACvC,MAAM,IAAI,GAAG,CAAC,IAAY,EAAS,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAAxD,QAAA,IAAI,QAAoD;AAErE,8EAA8E;AAC9E,4EAA4E;AAC5E,SAAgB,GAAG,CAAC,GAAG,EAAW;IAChC,MAAM,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACnB,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,GAAG,GAAU,IAAI,CAAC;IACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACnB,IAAI,IAAI,KAAK,SAAS;YAAE,MAAM;QAC9B,GAAG,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;IAC5C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,wDAAwD;AACxD,SAAgB,OAAO,CAAC,CAAQ,EAAE,CAAQ;IACxC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACpC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,GAAG,CAAC;QACT,KAAK,GAAG,CAAC;QACT,KAAK,GAAG;YACN,OAAO,IAAI,CAAC;QACd,KAAK,KAAK;YACR,OAAO,CAAC,CAAC,IAAI,KAAM,CAAc,CAAC,IAAI,CAAC;QACzC,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,EAAE,GAAG,CAAa,CAAC;YACzB,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;AACH,CAAC;AAED,mEAAmE;AACnE,kEAAkE;AAClE,SAAgB,YAAY,CAAC,CAAQ;IACnC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,GAAG;YACN,OAAO,GAAG,CAAC;QACb,KAAK,GAAG;YACN,OAAO,GAAG,CAAC;QACb,KAAK,GAAG;YACN,OAAO,GAAG,CAAC;QACb,KAAK,KAAK;YACR,OAAO,CAAC,CAAC,IAAI,CAAC;QAChB,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC9B,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACpF,OAAO,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC;QACxB,CAAC;IACH,CAAC;AACH,CAAC;AAED,6DAA6D;AAC7D,SAAgB,QAAQ,CAAC,CAAQ;IAC/B,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAChB,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,OAAO,CAAC,CAAQ,EAAE,GAAgB;IACzC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,KAAK;YACR,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAChB,OAAO;QACT,KAAK,KAAK;YACR,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;YACnB,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACpB,OAAO;QACT;YACE,OAAO;IACX,CAAC;AACH,CAAC"}

package/dist/constructive-reals/index.d.ts

@@ -0,0 +1,132 @@
+export interface CReal {
+    /**
+     * Devuelve una aproximación dyádica de x con error < 2^{-precision}.
+     * numerator / denominator ≈ x, denominator = 2^precision.
+     */
+    approx(precision: number): {
+        numerator: bigint;
+        denominator: bigint;
+    };
+}
+/** Eleva 2 a un entero no negativo. */
+declare function pow2(n: number): bigint;
+/**
+ * Divide entero con "round half away from zero".
+ *   shiftRight(x, k) ≈ x / 2^k redondeado.
+ * Garantiza |shiftRight(x,k) - x/2^k| ≤ 1/2.
+ */
+declare function shiftRight(x: bigint, k: number): bigint;
+/**
+ * Calcula el número de bits del entero (|x| en binario).
+ * bitLength(0) = 0, bitLength(1) = 1, bitLength(7) = 3, bitLength(8) = 4.
+ */
+declare function bitLength(x: bigint): number;
+export declare function fromInt(n: number | bigint): CReal;
+export declare function fromRational(p: number | bigint, q: number | bigint): CReal;
+export declare function neg(a: CReal): CReal;
+export declare function abs(a: CReal): CReal;
+/**
+ * add(a,b) a precisión p:
+ *   pedimos a y b a precisión p+2.
+ *   error de cada uno < 2^{-(p+2)} → error en a+b < 2·2^{-(p+2)} = 2^{-(p+1)}.
+ *   Al pasar de escala p+2 a p (shift de 2), introducimos error
+ *   de redondeo ≤ 1/2 en la unidad p, = 2^{-(p+1)}.
+ *   Total: < 2^{-(p+1)} + 2^{-(p+1)} = 2^{-p}.  ✓
+ */
+export declare function add(a: CReal, b: CReal): CReal;
+export declare function sub(a: CReal, b: CReal): CReal;
+/**
+ * mul(a,b) a precisión p:
+ *   Necesitamos cotas sobre |a| y |b|. Tomamos una aproximación gruesa
+ *   a precisión 0 para estimar el tamaño en bits.
+ *   Sean |a| ≤ 2^A, |b| ≤ 2^B (con A,B no-negativos).
+ *   Trabajamos a precisión p + A + B + 3.
+ *   En esa escala el producto cabe y la cota de error queda < 2^{-p}.
+ *
+ *   Detalle del error: si â = a + ε_a con |ε_a| < 2^{-w} y análogamente
+ *   para b̂ (w = work precision en los operandos), entonces
+ *      â·b̂ - a·b = a·ε_b + b·ε_a + ε_a·ε_b.
+ *   |a·ε_b| ≤ 2^A · 2^{-w}, idem para b.
+ *   Eligiendo w = p + A + B + 3 ese error queda < 2·2^{-(p+B+3)}
+ *   acotado holgadamente por 2^{-(p+1)}, y el shift final añade otro
+ *   2^{-(p+1)}, dando < 2^{-p}.
+ */
+export declare function mul(a: CReal, b: CReal): CReal;
+/**
+ * div(a,b) a precisión p (b ≠ 0).
+ *   Encontramos k tal que |b| ≥ 2^{-k}.
+ *   Necesitamos también cota superior A_bits sobre |a|.
+ *   Trabajamos a precisión w = p + 2k + A_bits + 4.
+ *
+ *   Si â = a + ε_a, b̂ = b + ε_b, entonces
+ *     â/b̂ - a/b = (ε_a · b - a · ε_b) / (b · b̂).
+ *   |b · b̂| ≥ (2^{-k}) · (2^{-k} - 2^{-w}) ≥ 2^{-2k-1}.
+ *   |ε_a · b| ≤ 2^{-w} · (|b̂|+2^{-w}).
+ *   |a · ε_b| ≤ |â+2^{-w}| · 2^{-w}.
+ *   Tomando w = p + 2k + A_bits + 4 acotamos por < 2^{-p}.
+ */
+export declare function div(a: CReal, b: CReal): CReal;
+/**
+ * sqrt(a) para a ≥ 0. Si a < 0 (detectado con cota), lanza.
+ * Implementación: Newton-Raphson en bigint sobre x² = N donde
+ * N = aprox(a) a precisión 2·prec + buffer. La raíz cuadrada entera
+ * de N da nuestra aproximación a √a a precisión prec.
+ */
+export declare function sqrt(a: CReal): CReal;
+/** Raíz cuadrada entera (floor) de n ≥ 0 vía Newton. */
+declare function isqrt(n: bigint): bigint;
+/**
+ * compareWithEpsilon(a, b, epsPrec):
+ *   Si |a - b| < 2^{-epsPrec}, devuelve 0 (indistinguibles).
+ *   Si a > b + 2^{-epsPrec}, devuelve 1.
+ *   Si a < b - 2^{-epsPrec}, devuelve -1.
+ *
+ *   Implementación: comparamos aproximaciones a precisión epsPrec + 3.
+ *   |aw/2^w - a| < 2^{-w}, idem b. Entonces
+ *     (aw - bw)/2^w  está dentro de  (a - b) ± 2·2^{-w}.
+ *   Eligiendo w = epsPrec + 3:
+ *     • Si (aw - bw) > 2^{w - epsPrec} + 2 = 8 + 2 = 10 (en escala w),
+ *       entonces a - b > 2^{-epsPrec}, devolvemos 1.
+ *     • Análogo para -10.
+ *     • En otro caso, devolvemos 0.
+ */
+export declare function compareWithEpsilon(a: CReal, b: CReal, epsilonPrecision: number): -1 | 0 | 1;
+/**
+ * toString(r, digits): representación decimal con `digits` dígitos
+ * después del punto. Usa precisión binaria suficiente:
+ *   2^p > 10^digits  ⇔  p > digits · log2(10) ≈ digits · 3.322.
+ * Tomamos p = ceil(digits · 4) + 8 para holgura.
+ */
+export declare function toString(r: CReal, digits: number): string;
+/**
+ * exp(x) = Σ x^k / k!. Para que la serie converja rápido reducimos
+ * primero el argumento: escribimos x = q · ln(2) + r con |r| ≤ ln(2)/2
+ * usando q = round(x / ln(2)). Luego exp(x) = 2^q · exp(r).
+ *
+ * Para esta versión inicial hacemos una reducción más simple: si
+ * |x| > 1, dividimos por 2^k hasta que |x/2^k| < 1, calculamos
+ * exp(x/2^k) por serie, y elevamos al cuadrado k veces (exp(y)² = exp(2y)).
+ * Esto mantiene la convergencia de la serie acotada a ~prec términos.
+ */
+export declare function exp(x: CReal): CReal;
+export declare function log(x: CReal): CReal;
+export declare function sin(x: CReal): CReal;
+export declare function cos(x: CReal): CReal;
+/**
+ * pow(a, b) = exp(b · log(a)) para a > 0.
+ * Caso especial: si b es un entero, hacemos exponenciación rápida
+ * sobre CReal para evitar log de a (lo que permite a ≤ 0 si b es entero).
+ */
+export declare function pow(a: CReal, b: CReal | number): CReal;
+export declare const PI: CReal;
+export declare const E: CReal;
+export declare const SQRT2: CReal;
+/** @internal Exposed for whitebox tests. */
+export declare const __internals: {
+    shiftRight: typeof shiftRight;
+    bitLength: typeof bitLength;
+    isqrt: typeof isqrt;
+    pow2: typeof pow2;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/constructive-reals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constructive-reals/index.ts"],"names":[],"mappings":"AA6CA,MAAM,WAAW,KAAK;IACpB;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACvE;AAID,uCAAuC;AACvC,iBAAS,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG/B;AAED;;;;GAIG;AACH,iBAAS,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;;GAGG;AACH,iBAAS,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAMpC;AA8DD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CASjD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAuB1E;AAID,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAGnC;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAMnC;AAED;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAQ7C;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAQ7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAoB7C;AAsBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CA2B7C;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAoBpC;AAED,wDAAwD;AACxD,iBAAS,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAahC;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAW3F;AAID;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgBzD;AAWD;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAqCnC;AAwBD,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CA0CnC;AA6CD,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAiBnC;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAenC;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,CAmBtD;AA2CD,eAAO,MAAM,EAAE,EAAE,KAAuC,CAAC;AAmBzD,eAAO,MAAM,CAAC,EAAE,KAAsC,CAAC;AAYvD,eAAO,MAAM,KAAK,EAAE,KAA0C,CAAC;AAI/D,4CAA4C;AAC5C,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC"}