@stevenvo780/st-lang 4.8.0 → 4.9.0

package/dist/proof-systems/certificate/rules.js

@@ -0,0 +1,369 @@
+"use strict";
+// ============================================================
+// ST Proof Certificate — Standard rule checkers
+// ============================================================
+//
+// Cada checker recibe (args, conclusion, premises) y retorna true
+// si el paso aplica la regla correctamente. NO hacen búsqueda — sólo
+// chequean estructura sintáctica de strings canonicalizados.
+//
+// Las fórmulas viajan como strings. Reconocemos los operadores
+// estándar de proposicional/clásico con variantes ASCII y Unicode:
+//
+//   negación:     ~ A   |   ¬A   |   !A   |   not A
+//   conjunción:   A & B |  A ∧ B |  A and B
+//   disyunción:   A | B |  A ∨ B |  A or B
+//   implicación:  A -> B |  A → B
+//   bicondicional: A <-> B |  A ↔ B
+//
+// Para minimizar dependencia con el AST interno, comparamos por
+// igualdad de la forma normalizada (`normalizeFormula`). Cuando
+// necesitamos descomponer un operador binario, escaneamos a top-level
+// respetando paréntesis.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STANDARD_RULES = void 0;
+const canonical_1 = require("./canonical");
+function strip(formula) {
+    let s = (0, canonical_1.normalizeFormula)(formula);
+    while (s.startsWith('(') && s.endsWith(')') && balancedOuter(s)) {
+        s = s.slice(1, -1).trim();
+    }
+    return s;
+}
+function balancedOuter(s) {
+    if (!s.startsWith('(') || !s.endsWith(')'))
+        return false;
+    let depth = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === '(')
+            depth++;
+        else if (c === ')') {
+            depth--;
+            if (depth === 0 && i < s.length - 1)
+                return false;
+        }
+    }
+    return depth === 0;
+}
+// Operadores binarios ordenados por precedencia (menor precedencia
+// primero — escaneamos de menor a mayor). Cada entrada es una lista
+// de spellings equivalentes.
+const BINARY_OPS = [
+    { name: 'iff', spellings: ['<->', '↔'] },
+    { name: 'implies', spellings: ['->', '→'] },
+    { name: 'or', spellings: ['|', '∨', ' or '] },
+    { name: 'and', spellings: ['&', '∧', ' and '] },
+];
+function findTopLevel(s, needle) {
+    let depth = 0;
+    for (let i = 0; i <= s.length - needle.length; i++) {
+        const c = s[i];
+        if (c === '(') {
+            depth++;
+            continue;
+        }
+        if (c === ')') {
+            depth--;
+            continue;
+        }
+        if (depth === 0 && s.startsWith(needle, i))
+            return i;
+    }
+    return -1;
+}
+function splitBinary(formula, opName) {
+    const s = strip(formula);
+    for (const op of BINARY_OPS) {
+        if (op.name !== opName)
+            continue;
+        for (const sp of op.spellings) {
+            const idx = findTopLevel(s, sp);
+            if (idx >= 0) {
+                const left = strip(s.slice(0, idx));
+                const right = strip(s.slice(idx + sp.length));
+                return { operator: opName, left, right };
+            }
+        }
+    }
+    return null;
+}
+function stripNot(formula) {
+    const s = strip(formula);
+    if (s.startsWith('~'))
+        return strip(s.slice(1));
+    if (s.startsWith('¬'))
+        return strip(s.slice(1));
+    if (s.startsWith('!'))
+        return strip(s.slice(1));
+    if (s.toLowerCase().startsWith('not '))
+        return strip(s.slice(4));
+    return null;
+}
+function eq(a, b) {
+    return strip(a) === strip(b);
+}
+// ---- Checkers ----
+const axiomChecker = (args, conclusion, premises) => {
+    // axiom: la conclusión es uno de los args (el nombre del axioma es
+    // la propia fórmula) y no hay premisas.
+    if (premises.length !== 0)
+        return false;
+    if (args.length === 0)
+        return false;
+    return args.some((a) => eq(a, conclusion));
+};
+const assumptionChecker = (_args, _conclusion, premises) => {
+    // assumption: no premisas (es una hipótesis local). El verificador
+    // global se encarga de comprobar que se descargue eventualmente.
+    return premises.length === 0;
+};
+const reiterationChecker = (_args, conclusion, premises) => {
+    // reit: una sola premisa idéntica a la conclusión.
+    if (premises.length !== 1)
+        return false;
+    return eq(premises[0], conclusion);
+};
+const modusPonensChecker = (_args, conclusion, premises) => {
+    // MP: premisas = [A -> B, A], conclusión = B
+    if (premises.length !== 2)
+        return false;
+    const [impl, ant] = premises;
+    const split = splitBinary(impl, 'implies');
+    if (!split)
+        return false;
+    return eq(split.left, ant) && eq(split.right, conclusion);
+};
+const modusTollensChecker = (_args, conclusion, premises) => {
+    // MT: premisas = [A -> B, ~B], conclusión = ~A
+    if (premises.length !== 2)
+        return false;
+    const [impl, notB] = premises;
+    const split = splitBinary(impl, 'implies');
+    if (!split)
+        return false;
+    const inside = stripNot(notB);
+    const concInside = stripNot(conclusion);
+    if (inside === null || concInside === null)
+        return false;
+    return eq(inside, split.right) && eq(concInside, split.left);
+};
+const andIntroChecker = (_args, conclusion, premises) => {
+    // ∧I: premisas = [A, B], conclusión = A & B
+    if (premises.length !== 2)
+        return false;
+    const split = splitBinary(conclusion, 'and');
+    if (!split)
+        return false;
+    return eq(split.left, premises[0]) && eq(split.right, premises[1]);
+};
+const andElimLeftChecker = (_args, conclusion, premises) => {
+    if (premises.length !== 1)
+        return false;
+    const split = splitBinary(premises[0], 'and');
+    if (!split)
+        return false;
+    return eq(split.left, conclusion);
+};
+const andElimRightChecker = (_args, conclusion, premises) => {
+    if (premises.length !== 1)
+        return false;
+    const split = splitBinary(premises[0], 'and');
+    if (!split)
+        return false;
+    return eq(split.right, conclusion);
+};
+const orIntroLeftChecker = (_args, conclusion, premises) => {
+    // ∨IL: premisa = A, conclusión = A | B (B arbitrario pero declarado en args[0])
+    if (premises.length !== 1)
+        return false;
+    const split = splitBinary(conclusion, 'or');
+    if (!split)
+        return false;
+    return eq(split.left, premises[0]);
+};
+const orIntroRightChecker = (_args, conclusion, premises) => {
+    if (premises.length !== 1)
+        return false;
+    const split = splitBinary(conclusion, 'or');
+    if (!split)
+        return false;
+    return eq(split.right, premises[0]);
+};
+const orElimChecker = (_args, conclusion, premises) => {
+    // ∨E: premisas = [A | B, A -> C, B -> C], conclusión = C
+    if (premises.length !== 3)
+        return false;
+    const disj = splitBinary(premises[0], 'or');
+    const impL = splitBinary(premises[1], 'implies');
+    const impR = splitBinary(premises[2], 'implies');
+    if (!disj || !impL || !impR)
+        return false;
+    return (eq(disj.left, impL.left) &&
+        eq(disj.right, impR.left) &&
+        eq(impL.right, conclusion) &&
+        eq(impR.right, conclusion));
+};
+const impliesIntroChecker = (args, conclusion, premises) => {
+    // →I: descarga la hipótesis declarada en args[0] de la sub-derivación
+    // que produjo `premises[0]`. Conclusión = args[0] -> premises[0].
+    // El checker se limita a la forma sintáctica.
+    if (premises.length !== 1)
+        return false;
+    if (args.length < 1)
+        return false;
+    const split = splitBinary(conclusion, 'implies');
+    if (!split)
+        return false;
+    return eq(split.left, args[0]) && eq(split.right, premises[0]);
+};
+const impliesElimChecker = modusPonensChecker;
+const notIntroChecker = (args, conclusion, premises) => {
+    // ¬I: de una sub-derivación de ⊥ asumiendo args[0], deriva ¬args[0].
+    // premises[0] debe ser ⊥ (false/bottom/⊥/_|_).
+    if (premises.length !== 1)
+        return false;
+    if (args.length < 1)
+        return false;
+    const inside = stripNot(conclusion);
+    if (inside === null)
+        return false;
+    const bottom = strip(premises[0]);
+    if (!['⊥', 'false', '_|_', 'bottom'].includes(bottom.toLowerCase())) {
+        return false;
+    }
+    return eq(inside, args[0]);
+};
+const notElimChecker = (_args, conclusion, premises) => {
+    // ¬E: premisas = [A, ~A], conclusión = ⊥
+    if (premises.length !== 2)
+        return false;
+    const a = premises[0];
+    const notA = stripNot(premises[1]);
+    if (notA === null)
+        return false;
+    if (!eq(a, notA))
+        return false;
+    const c = strip(conclusion).toLowerCase();
+    return ['⊥', 'false', '_|_', 'bottom'].includes(c);
+};
+const efqChecker = (_args, _conclusion, premises) => {
+    // ex falso: de ⊥ deriva cualquier cosa.
+    if (premises.length !== 1)
+        return false;
+    const b = strip(premises[0]).toLowerCase();
+    return ['⊥', 'false', '_|_', 'bottom'].includes(b);
+};
+const doubleNegElimChecker = (_args, conclusion, premises) => {
+    // ¬¬E: premisa = ~~A, conclusión = A. (clásico)
+    if (premises.length !== 1)
+        return false;
+    const inner1 = stripNot(premises[0]);
+    if (inner1 === null)
+        return false;
+    const inner2 = stripNot(inner1);
+    if (inner2 === null)
+        return false;
+    return eq(inner2, conclusion);
+};
+const doubleNegIntroChecker = (_args, conclusion, premises) => {
+    // ¬¬I: premisa = A, conclusión = ~~A.
+    if (premises.length !== 1)
+        return false;
+    const inner1 = stripNot(conclusion);
+    if (inner1 === null)
+        return false;
+    const inner2 = stripNot(inner1);
+    if (inner2 === null)
+        return false;
+    return eq(inner2, premises[0]);
+};
+const iffIntroChecker = (_args, conclusion, premises) => {
+    // ↔I: premisas = [A -> B, B -> A], conclusión = A <-> B
+    if (premises.length !== 2)
+        return false;
+    const fwd = splitBinary(premises[0], 'implies');
+    const bwd = splitBinary(premises[1], 'implies');
+    if (!fwd || !bwd)
+        return false;
+    if (!(eq(fwd.left, bwd.right) && eq(fwd.right, bwd.left)))
+        return false;
+    const iff = splitBinary(conclusion, 'iff');
+    if (!iff)
+        return false;
+    return eq(iff.left, fwd.left) && eq(iff.right, fwd.right);
+};
+const iffElimLeftChecker = (_args, conclusion, premises) => {
+    // ↔EL: premisa = A <-> B, conclusión = A -> B
+    if (premises.length !== 1)
+        return false;
+    const iff = splitBinary(premises[0], 'iff');
+    if (!iff)
+        return false;
+    const impl = splitBinary(conclusion, 'implies');
+    if (!impl)
+        return false;
+    return eq(iff.left, impl.left) && eq(iff.right, impl.right);
+};
+const iffElimRightChecker = (_args, conclusion, premises) => {
+    if (premises.length !== 1)
+        return false;
+    const iff = splitBinary(premises[0], 'iff');
+    if (!iff)
+        return false;
+    const impl = splitBinary(conclusion, 'implies');
+    if (!impl)
+        return false;
+    return eq(iff.left, impl.right) && eq(iff.right, impl.left);
+};
+/**
+ * Tabla de reglas estándar. El verificador busca primero en esta tabla
+ * (o en una tabla custom pasada como parámetro). Si la regla no
+ * existe, registra un error pero no aborta para listar todos.
+ */
+exports.STANDARD_RULES = new Map([
+    ['axiom', axiomChecker],
+    ['assumption', assumptionChecker],
+    ['hypothesis', assumptionChecker],
+    ['premise', axiomChecker],
+    ['reiteration', reiterationChecker],
+    ['reit', reiterationChecker],
+    ['modus-ponens', modusPonensChecker],
+    ['mp', modusPonensChecker],
+    ['implies-elim', impliesElimChecker],
+    ['->E', impliesElimChecker],
+    ['modus-tollens', modusTollensChecker],
+    ['mt', modusTollensChecker],
+    ['implies-intro', impliesIntroChecker],
+    ['->I', impliesIntroChecker],
+    ['and-intro', andIntroChecker],
+    ['&I', andIntroChecker],
+    ['conj-intro', andIntroChecker],
+    ['and-elim-left', andElimLeftChecker],
+    ['&EL', andElimLeftChecker],
+    ['and-elim-right', andElimRightChecker],
+    ['&ER', andElimRightChecker],
+    ['or-intro-left', orIntroLeftChecker],
+    ['|IL', orIntroLeftChecker],
+    ['or-intro-right', orIntroRightChecker],
+    ['|IR', orIntroRightChecker],
+    ['or-elim', orElimChecker],
+    ['|E', orElimChecker],
+    ['not-intro', notIntroChecker],
+    ['~I', notIntroChecker],
+    ['not-elim', notElimChecker],
+    ['~E', notElimChecker],
+    ['ex-falso', efqChecker],
+    ['efq', efqChecker],
+    ['double-neg-elim', doubleNegElimChecker],
+    ['~~E', doubleNegElimChecker],
+    ['double-neg-intro', doubleNegIntroChecker],
+    ['~~I', doubleNegIntroChecker],
+    ['iff-intro', iffIntroChecker],
+    ['<->I', iffIntroChecker],
+    ['iff-elim-left', iffElimLeftChecker],
+    ['<->EL', iffElimLeftChecker],
+    ['iff-elim-right', iffElimRightChecker],
+    ['<->ER', iffElimRightChecker],
+]);
+//# sourceMappingURL=rules.js.map

package/dist/proof-systems/certificate/rules.js.map

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

package/dist/proof-systems/certificate/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Un paso del certificado. Cada paso tiene un id único dentro del
+ * certificado, una regla declarada, una lista de argumentos
+ * (referencias a ids previos o términos literales), una conclusión
+ * derivada por aplicar la regla a las premisas, y la lista de ids
+ * de los pasos de los que depende.
+ *
+ * - `id`: identificador único en el certificado (e.g. `s1`, `step-3`).
+ * - `rule`: nombre canónico de la regla. Ver `STANDARD_RULES`.
+ * - `args`: lista de argumentos textuales para la regla. Para reglas
+ *   tipo `modus-ponens` los args suelen ser ids de premisas en el
+ *   orden esperado por la regla (e.g. `["s1", "s2"]`). Reglas como
+ *   `axiom` o `assumption` pueden tener `args` vacíos o incluir un
+ *   nombre del axioma.
+ * - `conclusion`: fórmula derivada en el paso, en forma canónica.
+ * - `depends`: ids de pasos previos referenciados (ya sea por args
+ *   o por contexto). El verificador valida que no haya ciclos y que
+ *   todos los ids citados existan.
+ */
+export interface CertStep {
+    id: string;
+    rule: string;
+    args: string[];
+    conclusion: string;
+    depends: string[];
+}
+/**
+ * Firma criptográfica de un certificado. Por defecto Ed25519 vía
+ * WebCrypto cuando está disponible; cae a HMAC-SHA256 en runtimes
+ * que no soporten Ed25519 (Node antiguo, Bun viejo).
+ */
+export interface CertSignature {
+    /** Algoritmo usado. */
+    algorithm: 'Ed25519' | 'HMAC-SHA256';
+    /** Clave pública en hex (raw export). Para HMAC: clave compartida. */
+    publicKey: string;
+    /** Firma en hex sobre la forma canónica sin hash ni signature. */
+    signature: string;
+}
+/**
+ * Certificado portable de prueba. Estructura inspirada en LFSC.
+ *
+ * `hash` es SHA-256 de la forma canónica del certificado SIN los
+ * campos `hash` ni `signature`. Esto permite verificar integridad
+ * antes y después de firmar.
+ *
+ * Ejemplo mínimo (modus ponens):
+ *
+ * ```ts
+ * const cert: ProofCertificate = {
+ *   version: '1.0',
+ *   goal: 'q',
+ *   profile: 'classical.propositional',
+ *   axioms: ['p', 'p -> q'],
+ *   steps: [
+ *     { id: 's1', rule: 'axiom', args: ['p'], conclusion: 'p', depends: [] },
+ *     { id: 's2', rule: 'axiom', args: ['p -> q'], conclusion: 'p -> q', depends: [] },
+ *     { id: 's3', rule: 'modus-ponens', args: ['s2', 's1'], conclusion: 'q', depends: ['s2', 's1'] },
+ *   ],
+ *   hash: '...',
+ * };
+ * ```
+ */
+export interface ProofCertificate {
+    version: '1.0';
+    /** Fórmula final probada, en forma canónica. */
+    goal: string;
+    /** Perfil lógico bajo el cual se interpreta la prueba. */
+    profile: string;
+    /** Axiomas asumidos sobre los que se construye la prueba. */
+    axioms: string[];
+    /** Pasos del certificado en orden topológico (deps antes que dependientes). */
+    steps: CertStep[];
+    /** SHA-256 hex de la forma canónica sin `hash` ni `signature`. */
+    hash: string;
+    /** Firma opcional. Si presente, debe verificar contra la forma canónica sin firma. */
+    signature?: CertSignature;
+}
+/**
+ * Resultado de verificar un certificado en modo check-only.
+ *
+ * `valid` sólo es `true` si TODOS los chequeos pasan:
+ *   - el hash coincide con la forma canónica del certificado;
+ *   - todos los ids son únicos y todas las referencias existen;
+ *   - no hay ciclos en `depends`;
+ *   - el goal aparece como conclusión de algún paso;
+ *   - cada paso aplica su regla correctamente vía
+ *     `CertRuleChecker` (regla declarada existe y el checker
+ *     retorna true para los args/conclusion/premisas).
+ *
+ * `errors` lista todas las violaciones detectadas; el verificador
+ * NO se detiene en la primera para dar feedback completo.
+ *
+ * `stepsVerified` cuenta los pasos cuya regla fue chequeada con
+ * éxito por su `CertRuleChecker`. `totalSteps` es `steps.length`.
+ */
+export interface VerificationResult {
+    valid: boolean;
+    errors: string[];
+    stepsVerified: number;
+    totalSteps: number;
+}
+/**
+ * Firma de un checker de regla. Recibe los argumentos crudos del
+ * paso, la conclusión declarada y las premisas resueltas (las
+ * conclusiones de los pasos referenciados en `depends`, en el
+ * orden en que aparecen en `depends`).
+ *
+ * Debe retornar `true` si y sólo si la regla se aplica
+ * correctamente. NO debe hacer búsqueda — sólo chequear estructura
+ * sintáctica de strings.
+ */
+export type CertRuleChecker = (args: string[], conclusion: string, premises: string[]) => boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/proof-systems/certificate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/certificate/types.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,uBAAuB;IACvB,SAAS,EAAE,SAAS,GAAG,aAAa,CAAC;IACrC,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,KAAK,CAAC;IACf,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,+EAA+E;IAC/E,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,sFAAsF;IACtF,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC"}

package/dist/proof-systems/certificate/types.js

@@ -0,0 +1,18 @@
+"use strict";
+// ============================================================
+// ST Proof Certificate — Tipos públicos
+// ============================================================
+//
+// Formato canónico portable para certificados de prueba inspirado
+// en LFSC (LF + Side Conditions) y Dedukti. La filosofía es
+// "check-only": el verificador NO hace búsqueda de prueba ni
+// resuelve fórmulas — sólo comprueba que cada paso aplica
+// correctamente una regla declarada sobre premisas ya derivadas.
+//
+// Las fórmulas viajan como strings en una representación canónica
+// definida por la profile/perfil. El verificador trata strings con
+// comparación literal previa normalización (trim + colapsar
+// whitespace interno). Esto hace al certificado independiente del
+// AST interno del prover y permite intercambio entre herramientas.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/proof-systems/certificate/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/proof-systems/certificate/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,wCAAwC;AACxC,+DAA+D;AAC/D,EAAE;AACF,kEAAkE;AAClE,4DAA4D;AAC5D,6DAA6D;AAC7D,0DAA0D;AAC1D,iEAAiE;AACjE,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,4DAA4D;AAC5D,kEAAkE;AAClE,mEAAmE"}

package/dist/proof-systems/certificate/verify.d.ts

@@ -0,0 +1,20 @@
+import { canonicalize } from './canonical';
+import type { CertRuleChecker, ProofCertificate, VerificationResult } from './types';
+/**
+ * Verifica un certificado en modo check-only.
+ *
+ * Las reglas custom (parámetro `rules`) se prueban PRIMERO; si no
+ * está la regla, se busca en `STANDARD_RULES`. Esto permite a
+ * profiles externos extender el conjunto sin tocar el core.
+ */
+export declare function verifyCertificate(cert: ProofCertificate, rules?: Map<string, CertRuleChecker>): Promise<VerificationResult>;
+/**
+ * Helper para construir un certificado "a mano" a partir de pasos
+ * crudos: rellena `hash` (y opcionalmente firma) y normaliza
+ * fórmulas.
+ *
+ * Acepta un objeto similar a `ProofCertificate` sin `hash`; las
+ * fórmulas se normalizan in-place vía `canonicalize`.
+ */
+export { canonicalize };
+//# sourceMappingURL=verify.d.ts.map

package/dist/proof-systems/certificate/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/certificate/verify.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,YAAY,EAAqC,MAAM,aAAa,CAAC;AAE9E,OAAO,KAAK,EAAE,eAAe,EAAY,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAyC/F;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,gBAAgB,EACtB,KAAK,GAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAkB,GACnD,OAAO,CAAC,kBAAkB,CAAC,CAkH7B;AAED;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,CAAC"}