@stevenvo780/st-lang 4.2.0 → 4.4.0

package/dist/lambda-calc/substitution.js

@@ -0,0 +1,120 @@
+"use strict";
+// ============================================================
+// λ-cálculo untyped — Variables libres, α-renombrado, sustitución
+// capture-avoiding
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freeVars = freeVars;
+exports.makeFreshSupply = makeFreshSupply;
+exports.alphaRename = alphaRename;
+exports.substitute = substitute;
+// Free variables del término.
+function freeVars(t) {
+    const acc = new Set();
+    collectFree(t, acc);
+    return acc;
+}
+function collectFree(t, acc) {
+    switch (t.kind) {
+        case 'var':
+            acc.add(t.name);
+            return;
+        case 'app':
+            collectFree(t.fn, acc);
+            collectFree(t.arg, acc);
+            return;
+        case 'abs': {
+            const inner = new Set();
+            collectFree(t.body, inner);
+            inner.delete(t.param);
+            for (const x of inner)
+                acc.add(x);
+            return;
+        }
+    }
+}
+// Conjunto de todos los nombres mencionados (libres o ligados).
+function allNames(t, acc = new Set()) {
+    switch (t.kind) {
+        case 'var':
+            acc.add(t.name);
+            return acc;
+        case 'app':
+            allNames(t.fn, acc);
+            allNames(t.arg, acc);
+            return acc;
+        case 'abs':
+            acc.add(t.param);
+            allNames(t.body, acc);
+            return acc;
+    }
+}
+// Generador de nombres frescos. Mantiene un contador local para
+// reproducibilidad — el patrón es `<base>#<n>`.
+function makeFreshSupply(seed = 0) {
+    let n = seed;
+    return () => `_x${n++}`;
+}
+function freshName(base, avoid) {
+    // Quita un sufijo `#N` previo para no acumular hashes.
+    const stripped = base.replace(/#\d+$/, '');
+    let i = 0;
+    let candidate = `${stripped}#${i}`;
+    while (avoid.has(candidate)) {
+        i += 1;
+        candidate = `${stripped}#${i}`;
+    }
+    return candidate;
+}
+// α-renombra todos los binders del término usando `freshSupply`. Útil
+// para canonicalizar términos sin ambigüedad de nombres.
+function alphaRename(t, freshSupply) {
+    return rename(t, new Map(), freshSupply);
+}
+function rename(t, env, supply) {
+    switch (t.kind) {
+        case 'var':
+            return { kind: 'var', name: env.get(t.name) ?? t.name };
+        case 'app':
+            return { kind: 'app', fn: rename(t.fn, env, supply), arg: rename(t.arg, env, supply) };
+        case 'abs': {
+            const fresh = supply();
+            const newEnv = new Map(env);
+            newEnv.set(t.param, fresh);
+            return { kind: 'abs', param: fresh, body: rename(t.body, newEnv, supply) };
+        }
+    }
+}
+// Sustitución capture-avoiding: t[varName := replacement].
+// Cuando un binder choca con FV(replacement), α-renombra el binder a
+// un nombre fresco antes de descender — evita captura silenciosa.
+function substitute(t, varName, replacement) {
+    const fvRep = freeVars(replacement);
+    return subst(t, varName, replacement, fvRep);
+}
+function subst(t, name, value, fvValue) {
+    switch (t.kind) {
+        case 'var':
+            return t.name === name ? value : t;
+        case 'app':
+            return {
+                kind: 'app',
+                fn: subst(t.fn, name, value, fvValue),
+                arg: subst(t.arg, name, value, fvValue),
+            };
+        case 'abs': {
+            if (t.param === name)
+                return t; // ligado: la sustitución se detiene
+            if (!fvValue.has(t.param)) {
+                return { kind: 'abs', param: t.param, body: subst(t.body, name, value, fvValue) };
+            }
+            // Captura inminente: renombra el binder.
+            const avoid = new Set([...fvValue, ...allNames(t.body)]);
+            avoid.add(name);
+            const fresh = freshName(t.param, avoid);
+            const renamedBody = subst(t.body, t.param, { kind: 'var', name: fresh }, new Set([fresh]));
+            return { kind: 'abs', param: fresh, body: subst(renamedBody, name, value, fvValue) };
+        }
+    }
+}
+//# sourceMappingURL=substitution.js.map

package/dist/lambda-calc/substitution.js.map

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

package/dist/lambda-calc/types.d.ts

@@ -0,0 +1,19 @@
+export type Term = {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'abs';
+    param: string;
+    body: Term;
+} | {
+    kind: 'app';
+    fn: Term;
+    arg: Term;
+};
+export declare const v: (name: string) => Term;
+export declare const lam: (param: string, body: Term) => Term;
+export declare const ap: (fn: Term, arg: Term) => Term;
+export declare const apN: (head: Term, ...args: Term[]) => Term;
+export declare function alphaEq(a: Term, b: Term): boolean;
+export declare function termToString(t: Term): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/lambda-calc/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lambda-calc/types.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,IAAI,GACZ;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,CAAC;AAGzC,eAAO,MAAM,CAAC,GAAI,MAAM,MAAM,KAAG,IAA+B,CAAC;AACjE,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,EAAE,MAAM,IAAI,KAAG,IAAsC,CAAC;AACvF,eAAO,MAAM,EAAE,GAAI,IAAI,IAAI,EAAE,KAAK,IAAI,KAAG,IAAkC,CAAC;AAG5E,eAAO,MAAM,GAAG,GAAI,MAAM,IAAI,EAAE,GAAG,MAAM,IAAI,EAAE,KAAG,IAA6B,CAAC;AAIhF,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAEjD;AAuCD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAY5C"}

package/dist/lambda-calc/types.js

@@ -0,0 +1,72 @@
+"use strict";
+// ============================================================
+// λ-cálculo untyped — Términos, constructores y serialización
+// ============================================================
+//
+// Distinto al módulo curry-howard (typed λ-cálculo con conexión a
+// deducción natural): aquí trabajamos λ puro, sin tipos, con
+// β/η-reducción, varias estrategias de normalización y los
+// combinadores clásicos (I, K, S, Y) + Church numerals.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apN = exports.ap = exports.lam = exports.v = void 0;
+exports.alphaEq = alphaEq;
+exports.termToString = termToString;
+// ---------- Constructores convenientes ----------
+const v = (name) => ({ kind: 'var', name });
+exports.v = v;
+const lam = (param, body) => ({ kind: 'abs', param, body });
+exports.lam = lam;
+const ap = (fn, arg) => ({ kind: 'app', fn, arg });
+exports.ap = ap;
+// Aplicación n-aria por la izquierda: apN(f, a, b, c) = ((f a) b) c
+const apN = (head, ...args) => args.reduce(exports.ap, head);
+exports.apN = apN;
+// Igualdad estructural módulo α (alpha-equivalencia).
+// Compara términos renombrando binders a posiciones canónicas.
+function alphaEq(a, b) {
+    return alphaEqEnv(a, b, new Map(), new Map(), { n: 0 });
+}
+function alphaEqEnv(a, b, envA, envB, counter) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'var': {
+            const bb = b;
+            const ia = envA.get(a.name);
+            const ib = envB.get(bb.name);
+            if (ia === undefined && ib === undefined)
+                return a.name === bb.name; // free vars
+            return ia === ib;
+        }
+        case 'abs': {
+            const bb = b;
+            const idx = counter.n++;
+            const newA = new Map(envA);
+            newA.set(a.param, idx);
+            const newB = new Map(envB);
+            newB.set(bb.param, idx);
+            return alphaEqEnv(a.body, bb.body, newA, newB, counter);
+        }
+        case 'app': {
+            const bb = b;
+            return (alphaEqEnv(a.fn, bb.fn, envA, envB, counter) &&
+                alphaEqEnv(a.arg, bb.arg, envA, envB, counter));
+        }
+    }
+}
+// Pretty-printer minimalista. Aplicación es asociativa a la izquierda,
+// abstracción se extiende lo más posible a la derecha.
+function termToString(t) {
+    switch (t.kind) {
+        case 'var':
+            return t.name;
+        case 'abs':
+            return `(λ${t.param}.${termToString(t.body)})`;
+        case 'app': {
+            const fn = termToString(t.fn);
+            const arg = t.arg.kind === 'app' ? `(${termToString(t.arg)})` : termToString(t.arg);
+            return `(${fn} ${arg})`;
+        }
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/lambda-calc/types.js.map

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

package/dist/mltt/equality.d.ts

@@ -0,0 +1,9 @@
+import type { MLTTTerm } from './types';
+/** α-equivalencia estructural sobre términos (no normaliza). */
+export declare function alphaEq(a: MLTTTerm, b: MLTTTerm): boolean;
+/**
+ * Igualdad αβ (definicional): normaliza ambos y luego compara α.
+ * `ctx` reservado para implementaciones futuras (η, definitional unfolding).
+ */
+export declare function alphaBetaEq(a: MLTTTerm, b: MLTTTerm, _ctx?: Map<string, MLTTTerm>): boolean;
+//# sourceMappingURL=equality.d.ts.map

package/dist/mltt/equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality.d.ts","sourceRoot":"","sources":["../../src/mltt/equality.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC,gEAAgE;AAChE,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAyDzD;AAID;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,OAAO,CAE3F"}

package/dist/mltt/equality.js

@@ -0,0 +1,79 @@
+"use strict";
+// ============================================================
+// MLTT — α-equivalencia y igualdad definicional (αβ-equality)
+// ============================================================
+//
+// Igualdad definicional ≡ normalizamos ambos lados (β + ι) y
+// comparamos módulo α-renombrado de binders.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alphaEq = alphaEq;
+exports.alphaBetaEq = alphaBetaEq;
+const normalize_1 = require("./normalize");
+const substitute_1 = require("./substitute");
+/** α-equivalencia estructural sobre términos (no normaliza). */
+function alphaEq(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'var':
+            return a.name === b.name;
+        case 'universe':
+            return a.level === b.level;
+        case 'nat':
+        case 'zero':
+            return true;
+        case 'succ':
+            return alphaEq(a.arg, b.arg);
+        case 'app': {
+            const bb = b;
+            return alphaEq(a.fn, bb.fn) && alphaEq(a.arg, bb.arg);
+        }
+        case 'pair': {
+            const bb = b;
+            return alphaEq(a.fst, bb.fst) && alphaEq(a.snd, bb.snd);
+        }
+        case 'fst':
+        case 'snd': {
+            const bb = b;
+            return alphaEq(a.pair, bb.pair);
+        }
+        case 'identity': {
+            const bb = b;
+            return alphaEq(a.type, bb.type) && alphaEq(a.left, bb.left) && alphaEq(a.right, bb.right);
+        }
+        case 'refl':
+            return alphaEq(a.term, b.term);
+        case 'pi':
+        case 'sigma': {
+            const bb = b;
+            const aDom = a.kind === 'pi' ? a.domain : a.first;
+            const bDom = bb.kind === 'pi' ? bb.domain : bb.first;
+            const aCod = a.kind === 'pi' ? a.codomain : a.second;
+            const bCod = bb.kind === 'pi' ? bb.codomain : bb.second;
+            if (!alphaEq(aDom, bDom))
+                return false;
+            if (a.bind === bb.bind)
+                return alphaEq(aCod, bCod);
+            const fresh = `__α${alphaCounter++}`;
+            return alphaEq((0, substitute_1.substitute)(aCod, a.bind, { kind: 'var', name: fresh }), (0, substitute_1.substitute)(bCod, bb.bind, { kind: 'var', name: fresh }));
+        }
+        case 'lam': {
+            const bb = b;
+            if (!alphaEq(a.domain, bb.domain))
+                return false;
+            if (a.bind === bb.bind)
+                return alphaEq(a.body, bb.body);
+            const fresh = `__α${alphaCounter++}`;
+            return alphaEq((0, substitute_1.substitute)(a.body, a.bind, { kind: 'var', name: fresh }), (0, substitute_1.substitute)(bb.body, bb.bind, { kind: 'var', name: fresh }));
+        }
+    }
+}
+let alphaCounter = 0;
+/**
+ * Igualdad αβ (definicional): normaliza ambos y luego compara α.
+ * `ctx` reservado para implementaciones futuras (η, definitional unfolding).
+ */
+function alphaBetaEq(a, b, _ctx) {
+    return alphaEq((0, normalize_1.normalize)(a), (0, normalize_1.normalize)(b));
+}
+//# sourceMappingURL=equality.js.map

package/dist/mltt/equality.js.map

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

package/dist/mltt/index.d.ts

@@ -0,0 +1,8 @@
+export type { MLTTTerm } from './types';
+export { mVar, mUniverse, mPi, mLam, mApp, mSigma, mPair, mFst, mSnd, mId, mRefl, mNat, mZero, mSucc, mArrow, freeVars, occursFree, termToString, } from './types';
+export { substitute } from './substitute';
+export { reduceStep, normalize, isNormal } from './normalize';
+export { alphaEq, alphaBetaEq } from './equality';
+export { inferType, checkType, isInferError } from './infer';
+export type { InferContext, InferResult } from './infer';
+//# sourceMappingURL=index.d.ts.map

package/dist/mltt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mltt/index.ts"],"names":[],"mappings":"AAcA,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EACL,IAAI,EACJ,SAAS,EACT,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,KAAK,EACL,IAAI,EACJ,KAAK,EACL,KAAK,EACL,MAAM,EACN,QAAQ,EACR,UAAU,EACV,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7D,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/mltt/index.js

@@ -0,0 +1,49 @@
+"use strict";
+// ============================================================
+// MLTT — Martin-Löf Type Theory (núcleo público)
+// ============================================================
+//
+// Cálculo λ con tipos dependientes:
+//   - Π (x : A). B(x)          funciones dependientes
+//   - Σ (x : A). B(x)          pares dependientes
+//   - Id(A, a, b) + refl       tipo identidad propositional
+//   - Type i jerárquico        universos
+//   - Nat / zero / succ        naturales como tipo base
+//
+// inferType / checkType / normalize / alphaBetaEq son la API mínima
+// para construir lenguajes tipo Coq/Agda didácticos encima.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInferError = exports.checkType = exports.inferType = exports.alphaBetaEq = exports.alphaEq = exports.isNormal = exports.normalize = exports.reduceStep = exports.substitute = exports.termToString = exports.occursFree = exports.freeVars = exports.mArrow = exports.mSucc = exports.mZero = exports.mNat = exports.mRefl = exports.mId = exports.mSnd = exports.mFst = exports.mPair = exports.mSigma = exports.mApp = exports.mLam = exports.mPi = exports.mUniverse = exports.mVar = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "mVar", { enumerable: true, get: function () { return types_1.mVar; } });
+Object.defineProperty(exports, "mUniverse", { enumerable: true, get: function () { return types_1.mUniverse; } });
+Object.defineProperty(exports, "mPi", { enumerable: true, get: function () { return types_1.mPi; } });
+Object.defineProperty(exports, "mLam", { enumerable: true, get: function () { return types_1.mLam; } });
+Object.defineProperty(exports, "mApp", { enumerable: true, get: function () { return types_1.mApp; } });
+Object.defineProperty(exports, "mSigma", { enumerable: true, get: function () { return types_1.mSigma; } });
+Object.defineProperty(exports, "mPair", { enumerable: true, get: function () { return types_1.mPair; } });
+Object.defineProperty(exports, "mFst", { enumerable: true, get: function () { return types_1.mFst; } });
+Object.defineProperty(exports, "mSnd", { enumerable: true, get: function () { return types_1.mSnd; } });
+Object.defineProperty(exports, "mId", { enumerable: true, get: function () { return types_1.mId; } });
+Object.defineProperty(exports, "mRefl", { enumerable: true, get: function () { return types_1.mRefl; } });
+Object.defineProperty(exports, "mNat", { enumerable: true, get: function () { return types_1.mNat; } });
+Object.defineProperty(exports, "mZero", { enumerable: true, get: function () { return types_1.mZero; } });
+Object.defineProperty(exports, "mSucc", { enumerable: true, get: function () { return types_1.mSucc; } });
+Object.defineProperty(exports, "mArrow", { enumerable: true, get: function () { return types_1.mArrow; } });
+Object.defineProperty(exports, "freeVars", { enumerable: true, get: function () { return types_1.freeVars; } });
+Object.defineProperty(exports, "occursFree", { enumerable: true, get: function () { return types_1.occursFree; } });
+Object.defineProperty(exports, "termToString", { enumerable: true, get: function () { return types_1.termToString; } });
+var substitute_1 = require("./substitute");
+Object.defineProperty(exports, "substitute", { enumerable: true, get: function () { return substitute_1.substitute; } });
+var normalize_1 = require("./normalize");
+Object.defineProperty(exports, "reduceStep", { enumerable: true, get: function () { return normalize_1.reduceStep; } });
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return normalize_1.normalize; } });
+Object.defineProperty(exports, "isNormal", { enumerable: true, get: function () { return normalize_1.isNormal; } });
+var equality_1 = require("./equality");
+Object.defineProperty(exports, "alphaEq", { enumerable: true, get: function () { return equality_1.alphaEq; } });
+Object.defineProperty(exports, "alphaBetaEq", { enumerable: true, get: function () { return equality_1.alphaBetaEq; } });
+var infer_1 = require("./infer");
+Object.defineProperty(exports, "inferType", { enumerable: true, get: function () { return infer_1.inferType; } });
+Object.defineProperty(exports, "checkType", { enumerable: true, get: function () { return infer_1.checkType; } });
+Object.defineProperty(exports, "isInferError", { enumerable: true, get: function () { return infer_1.isInferError; } });
+//# sourceMappingURL=index.js.map

package/dist/mltt/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mltt/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iDAAiD;AACjD,+DAA+D;AAC/D,EAAE;AACF,oCAAoC;AACpC,sDAAsD;AACtD,kDAAkD;AAClD,4DAA4D;AAC5D,yCAAyC;AACzC,wDAAwD;AACxD,EAAE;AACF,oEAAoE;AACpE,4DAA4D;;;AAG5D,iCAmBiB;AAlBf,6FAAA,IAAI,OAAA;AACJ,kGAAA,SAAS,OAAA;AACT,4FAAA,GAAG,OAAA;AACH,6FAAA,IAAI,OAAA;AACJ,6FAAA,IAAI,OAAA;AACJ,+FAAA,MAAM,OAAA;AACN,8FAAA,KAAK,OAAA;AACL,6FAAA,IAAI,OAAA;AACJ,6FAAA,IAAI,OAAA;AACJ,4FAAA,GAAG,OAAA;AACH,8FAAA,KAAK,OAAA;AACL,6FAAA,IAAI,OAAA;AACJ,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,+FAAA,MAAM,OAAA;AACN,iGAAA,QAAQ,OAAA;AACR,mGAAA,UAAU,OAAA;AACV,qGAAA,YAAY,OAAA;AAGd,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AACnB,yCAA8D;AAArD,uGAAA,UAAU,OAAA;AAAE,sGAAA,SAAS,OAAA;AAAE,qGAAA,QAAQ,OAAA;AACxC,uCAAkD;AAAzC,mGAAA,OAAO,OAAA;AAAE,uGAAA,WAAW,OAAA;AAC7B,iCAA6D;AAApD,kGAAA,SAAS,OAAA;AAAE,kGAAA,SAAS,OAAA;AAAE,qGAAA,YAAY,OAAA"}

package/dist/mltt/infer.d.ts

@@ -0,0 +1,17 @@
+import type { MLTTTerm } from './types';
+export type InferContext = Map<string, MLTTTerm>;
+export type InferResult = MLTTTerm | {
+    error: string;
+};
+export declare function isInferError(r: InferResult): r is {
+    error: string;
+};
+/** Infiere el tipo de `term` o devuelve un error legible. */
+export declare function inferType(term: MLTTTerm, ctx?: InferContext): InferResult;
+/**
+ * Chequea que `term` tenga el tipo `expected` (bajo αβ-equality).
+ * Implementa el modo "check" donde para `pair` se conoce el Σ esperado
+ * y se permite la dependencia del segundo componente.
+ */
+export declare function checkType(term: MLTTTerm, expected: MLTTTerm, ctx?: InferContext): boolean;
+//# sourceMappingURL=infer.d.ts.map

package/dist/mltt/infer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.d.ts","sourceRoot":"","sources":["../../src/mltt/infer.ts"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMxC,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AACjD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,IAAI;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAEnE;AAID,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,GAAE,YAAyB,GAAG,WAAW,CAmJrF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAClB,GAAG,GAAE,YAAyB,GAC7B,OAAO,CA0BT"}