@rsconcept/domain 1.0.0

package/dist/rslang/semantic/type-auditor.js

@@ -0,0 +1,1570 @@
+// src/parsing/ast.ts
+var TOKEN_ERROR = 0;
+function getNodeText(node) {
+  if (node.data.dataType === "string" && typeof node.data.value === "string") {
+    return node.data.value;
+  }
+  return `NO DATA NODE: ${node.typeID}`;
+}
+function getNodeIndices(node) {
+  if (node.data.dataType === "string[]" && Array.isArray(node.data.value)) {
+    return node.data.value.map((s) => parseInt(s, 10)).filter((n) => !isNaN(n));
+  }
+  return [];
+}
+
+// src/rslang/ast-annotations.ts
+var AST_ERRORS_KEY = "rsErrors";
+var AST_TYPE_KEY = "rsType";
+function annotateType(node, type) {
+  node.annotation = {
+    ...typeof node.annotation === "object" && node.annotation !== null ? node.annotation : {},
+    [AST_TYPE_KEY]: type
+  };
+}
+function annotateError(node, code, params) {
+  if (typeof node.annotation === "object" && node.annotation !== null && AST_ERRORS_KEY in node.annotation && isAstNodeErrorRef(node.annotation[AST_ERRORS_KEY])) {
+    return;
+  }
+  const entry = params !== void 0 && params.length > 0 ? { code, params: [...params] } : { code };
+  node.annotation = {
+    ...typeof node.annotation === "object" && node.annotation !== null ? node.annotation : {},
+    [AST_ERRORS_KEY]: entry
+  };
+}
+function isAstNodeErrorRef(x) {
+  if (typeof x !== "object" || x === null || !("code" in x)) {
+    return false;
+  }
+  const code = x.code;
+  if (typeof code !== "number") {
+    return false;
+  }
+  if (!("params" in x)) {
+    return true;
+  }
+  const p = x.params;
+  if (p === void 0) {
+    return true;
+  }
+  return Array.isArray(p) && p.every((item) => typeof item === "string");
+}
+
+// src/rslang/error.ts
+var RSErrorCode = {
+  unknownSyntax: 33792,
+  // 33792
+  missingParenthesis: 33798,
+  // 33798
+  missingCurlyBrace: 33799,
+  // 33799
+  missingSquareBracket: 33800,
+  // 33800
+  bracketMismatch: 33801,
+  // 33801
+  doubleParenthesis: 33802,
+  // 33802
+  missingOpenBracket: 33803,
+  // 33803
+  expectedLocal: 33813,
+  // 33813
+  expectedType: 33814,
+  // 33814
+  localDoubleDeclare: 10241,
+  // 10241
+  localNotUsed: 10242,
+  // 10242
+  localUndeclared: 34817,
+  // 34817
+  localShadowing: 34818,
+  // 34818
+  typesNotEqual: 34819,
+  // 34819
+  globalNotTyped: 34820,
+  // 34820
+  invalidDecart: 34821,
+  // 34821
+  invalidBoolean: 34822,
+  // 34822
+  invalidTypeOperation: 34823,
+  // 34823
+  invalidCard: 34824,
+  // 34824
+  invalidDebool: 34825,
+  // 34825
+  globalFuncWithoutArgs: 34827,
+  // 34827
+  invalidReduce: 34832,
+  // 34832
+  invalidProjectionTuple: 34833,
+  // 34833
+  invalidProjectionSet: 34834,
+  // 34834
+  invalidEnumeration: 34835,
+  // 34835
+  invalidCortegeDeclare: 34836,
+  // 34836
+  localOutOfScope: 34837,
+  // 34837
+  invalidElementPredicate: 34838,
+  // 34838
+  invalidEmptySetUsage: 34839,
+  // 34839
+  invalidArgsArity: 34840,
+  // 34840
+  invalidArgumentType: 34841,
+  // 34841
+  globalStructure: 34844,
+  // 34844
+  radicalUsage: 34849,
+  // 34849
+  invalidFilterArgumentType: 34850,
+  // 34850
+  invalidFilterArity: 34851,
+  // 34851
+  arithmeticNotSupported: 34852,
+  // 34852
+  typesNotCompatible: 34853,
+  // 34853
+  orderingNotSupported: 34854,
+  // 34854
+  expectedLogic: 34855,
+  // 34855
+  expectedSetexpr: 34856,
+  // 34856
+  invalidArgumentCortegeDeclare: 34857,
+  // 34857
+  globalNoValue: 34880,
+  // 34880
+  invalidPropertyUsage: 34881,
+  // 34881
+  // Value evaluation (runtime)
+  calcUnknownError: 33024,
+  // 35328
+  setOverflow: 33025,
+  // 35329
+  booleanBaseLimit: 33026,
+  // 35330
+  calcGlobalMissing: 33027,
+  // 35331
+  iterationsLimit: 33028,
+  // 35332
+  calcInvalidDebool: 33029,
+  // 35333
+  iterateInfinity: 33030,
+  // 35334
+  calculationNotSupported: 33031,
+  // 35335
+  cstEmptyDerived: 34913,
+  // 34913
+  definitionNotAllowed: 34914
+  // 34914
+};
+
+// src/rslang/parser/token.ts
+var TokenID = {
+  // Global, local IDs and literals
+  ERROR: TOKEN_ERROR,
+  ID_LOCAL: 258,
+  ID_GLOBAL: 259,
+  ID_FUNCTION: 260,
+  ID_PREDICATE: 261,
+  ID_RADICAL: 262,
+  LIT_INTEGER: 263,
+  LIT_WHOLE_NUMBERS: 264,
+  LIT_EMPTYSET: 265,
+  // Arithmetic
+  PLUS: 266,
+  MINUS: 267,
+  MULTIPLY: 268,
+  // Integer predicate symbols
+  GREATER: 269,
+  LESSER: 270,
+  GREATER_OR_EQ: 271,
+  LESSER_OR_EQ: 272,
+  // Equality comparison
+  EQUAL: 273,
+  NOTEQUAL: 274,
+  // Logic predicate symbols
+  QUANTOR_UNIVERSAL: 275,
+  QUANTOR_EXISTS: 276,
+  LOGIC_NOT: 277,
+  LOGIC_EQUIVALENT: 278,
+  LOGIC_IMPLICATION: 279,
+  LOGIC_OR: 280,
+  LOGIC_AND: 281,
+  // Set theory predicate symbols
+  SET_IN: 282,
+  SET_NOT_IN: 283,
+  SUBSET: 284,
+  SUBSET_OR_EQ: 285,
+  NOT_SUBSET: 286,
+  // Set theory operators
+  DECART: 287,
+  SET_UNION: 288,
+  SET_INTERSECTION: 289,
+  SET_MINUS: 290,
+  SET_SYMMETRIC_MINUS: 291,
+  BOOLEAN: 292,
+  // Structure operations
+  BIGPR: 293,
+  SMALLPR: 294,
+  FILTER: 295,
+  CARD: 296,
+  BOOL: 297,
+  DEBOOL: 298,
+  REDUCE: 299,
+  // Term constructions prefixes
+  DECLARATIVE: 300,
+  RECURSIVE: 301,
+  IMPERATIVE: 302,
+  ITERATE: 303,
+  ASSIGN: 304,
+  // Punctuation
+  PUNCTUATION_DEFINE: 305,
+  PUNCTUATION_STRUCT: 306,
+  PUNCTUATION_PL: 307,
+  PUNCTUATION_PR: 308,
+  PUNCTUATION_CL: 309,
+  PUNCTUATION_CR: 310,
+  PUNCTUATION_SL: 311,
+  PUNCTUATION_SR: 312,
+  PUNCTUATION_BAR: 313,
+  PUNCTUATION_COMMA: 314,
+  PUNCTUATION_SEMICOLON: 315,
+  // ======= Non-terminal tokens =========
+  NT_ENUM_DECL: 316,
+  NT_TUPLE: 317,
+  NT_ENUMERATION: 318,
+  NT_TUPLE_DECL: 319,
+  NT_ARG_DECL: 320,
+  NT_FUNC_DEFINITION: 321,
+  NT_ARGUMENTS: 322,
+  NT_FUNC_CALL: 323,
+  NT_DECLARATIVE_EXPR: 324,
+  NT_IMPERATIVE_EXPR: 325,
+  NT_RECURSIVE_FULL: 326,
+  NT_RECURSIVE_SHORT: 327,
+  // ======= Helper tokens ========
+  INTERRUPT: 328,
+  END: 329
+};
+
+// src/rslang/semantic/typification.ts
+var TypeID = {
+  anyTypification: 1,
+  integer: 2,
+  basic: 3,
+  tuple: 4,
+  collection: 5,
+  logic: 6,
+  function: 7,
+  predicate: 8
+};
+var TypeClass = {
+  logic: 1,
+  typification: 2,
+  function: 3,
+  predicate: 4
+};
+var LogicT = { typeID: TypeID.logic };
+var IntegerT = {
+  typeID: TypeID.integer,
+  isOrdered: true,
+  isArithmetic: true,
+  isIntegerCompatible: true
+};
+var AnyTypificationT = { typeID: TypeID.anyTypification };
+var EmptySetT = bool(AnyTypificationT);
+function bool(base) {
+  return { typeID: TypeID.collection, base };
+}
+function tuple(factors) {
+  if (factors.length < 2) {
+    throw new Error("Tuple with less than two factors is not allowed");
+  }
+  return { typeID: TypeID.tuple, factors };
+}
+function debool(target) {
+  return target.base;
+}
+function component(target, index) {
+  return target.factors[index - 1] ?? null;
+}
+function isTypification(type) {
+  return type?.typeID === TypeID.basic || type?.typeID === TypeID.anyTypification || type?.typeID === TypeID.integer || type?.typeID === TypeID.collection || type?.typeID === TypeID.tuple;
+}
+function isRadical(alias) {
+  return alias.length > 0 && alias.startsWith("R") && alias[1] !== "0";
+}
+
+// src/rslang/labels.ts
+var INTEGER_TYPE_NAME = "Z";
+var ANY_TYPE_NAME = "R0";
+var LOGIC_TYPE_NAME = "Logic";
+var labelTokenRecord = {
+  [TokenID.DECART]: "\xD7",
+  [TokenID.PUNCTUATION_PL]: "( )",
+  [TokenID.PUNCTUATION_SL]: "[ ]",
+  [TokenID.QUANTOR_UNIVERSAL]: "\u2200",
+  [TokenID.QUANTOR_EXISTS]: "\u2203",
+  [TokenID.LOGIC_NOT]: "\xAC",
+  [TokenID.LOGIC_AND]: "&",
+  [TokenID.LOGIC_OR]: "\u2228",
+  [TokenID.LOGIC_IMPLICATION]: "\u21D2",
+  [TokenID.LOGIC_EQUIVALENT]: "\u21D4",
+  [TokenID.LIT_EMPTYSET]: "\u2205",
+  [TokenID.LIT_WHOLE_NUMBERS]: "Z",
+  [TokenID.MULTIPLY]: "*",
+  [TokenID.EQUAL]: "=",
+  [TokenID.NOTEQUAL]: "\u2260",
+  [TokenID.GREATER_OR_EQ]: "\u2265",
+  [TokenID.LESSER_OR_EQ]: "\u2264",
+  [TokenID.SET_IN]: "\u2208",
+  [TokenID.SET_NOT_IN]: "\u2209",
+  [TokenID.SUBSET_OR_EQ]: "\u2286",
+  [TokenID.SUBSET]: "\u2282",
+  [TokenID.NOT_SUBSET]: "\u2284",
+  [TokenID.SET_INTERSECTION]: "\u2229",
+  [TokenID.SET_UNION]: "\u222A",
+  [TokenID.SET_MINUS]: "\\",
+  [TokenID.SET_SYMMETRIC_MINUS]: "\u2206",
+  [TokenID.BOOLEAN]: "\u212C()",
+  [TokenID.NT_DECLARATIVE_EXPR]: "D{}",
+  [TokenID.NT_IMPERATIVE_EXPR]: "I{}",
+  [TokenID.NT_RECURSIVE_FULL]: "R{}",
+  [TokenID.BIGPR]: "Pr1()",
+  [TokenID.SMALLPR]: "pr1()",
+  [TokenID.FILTER]: "Fi1[]()",
+  [TokenID.REDUCE]: "red()",
+  [TokenID.CARD]: "card()",
+  [TokenID.BOOL]: "bool()",
+  [TokenID.DEBOOL]: "debool()",
+  [TokenID.ASSIGN]: ":=",
+  [TokenID.ITERATE]: ":\u2208"
+};
+function labelToken(id) {
+  const text = labelTokenRecord[id];
+  return text ?? "UNKNOWN TOKEN: " + String(id);
+}
+function labelRSLangNode(node) {
+  switch (node.typeID) {
+    case TokenID.ERROR:
+      return "[ERROR]";
+    case TokenID.ID_LOCAL:
+    case TokenID.ID_GLOBAL:
+    case TokenID.ID_FUNCTION:
+    case TokenID.ID_PREDICATE:
+    case TokenID.ID_RADICAL:
+      return node.data.value;
+    case TokenID.LIT_INTEGER:
+      return String(node.data.value);
+    case TokenID.BIGPR:
+      return "Pr" + node.data.value.toString();
+    case TokenID.SMALLPR:
+      return "pr" + node.data.value.toString();
+    case TokenID.FILTER:
+      return "Fi" + node.data.value.toString();
+    case TokenID.NT_DECLARATIVE_EXPR:
+      return "DECLARATIVE";
+    case TokenID.NT_IMPERATIVE_EXPR:
+      return "IMPERATIVE";
+    case TokenID.NT_RECURSIVE_FULL:
+      return "RECURSIVE";
+    case TokenID.NT_RECURSIVE_SHORT:
+      return "RECURSIVE";
+    case TokenID.BOOLEAN:
+      return "\u212C";
+    case TokenID.REDUCE:
+      return "red";
+    case TokenID.CARD:
+      return "card";
+    case TokenID.BOOL:
+      return "bool";
+    case TokenID.DEBOOL:
+      return "debool";
+    case TokenID.PLUS:
+      return "+";
+    case TokenID.MINUS:
+      return "-";
+    case TokenID.MULTIPLY:
+      return "*";
+    case TokenID.GREATER:
+      return ">";
+    case TokenID.LESSER:
+      return "<";
+    case TokenID.NT_TUPLE:
+      return "TUPLE";
+    case TokenID.NT_ENUMERATION:
+      return "ENUM";
+    case TokenID.NT_ENUM_DECL:
+      return "ENUM_DECLARE";
+    case TokenID.NT_TUPLE_DECL:
+      return "TUPLE_DECLARE";
+    case TokenID.PUNCTUATION_DEFINE:
+      return "DEFINITION";
+    case TokenID.PUNCTUATION_STRUCT:
+      return "STRUCTURE_DEFINE";
+    case TokenID.NT_ARG_DECL:
+      return "ARG";
+    case TokenID.NT_FUNC_CALL:
+      return "CALL";
+    case TokenID.NT_ARGUMENTS:
+      return "ARGS";
+    case TokenID.NT_FUNC_DEFINITION:
+      return "FUNCTION_DEFINE";
+    case TokenID.DECART:
+    case TokenID.QUANTOR_UNIVERSAL:
+    case TokenID.QUANTOR_EXISTS:
+    case TokenID.LOGIC_NOT:
+    case TokenID.LOGIC_AND:
+    case TokenID.LOGIC_OR:
+    case TokenID.LOGIC_IMPLICATION:
+    case TokenID.LOGIC_EQUIVALENT:
+    case TokenID.LIT_EMPTYSET:
+    case TokenID.LIT_WHOLE_NUMBERS:
+    case TokenID.EQUAL:
+    case TokenID.NOTEQUAL:
+    case TokenID.GREATER_OR_EQ:
+    case TokenID.LESSER_OR_EQ:
+    case TokenID.SET_IN:
+    case TokenID.SET_NOT_IN:
+    case TokenID.SUBSET_OR_EQ:
+    case TokenID.SUBSET:
+    case TokenID.NOT_SUBSET:
+    case TokenID.SET_INTERSECTION:
+    case TokenID.SET_UNION:
+    case TokenID.SET_MINUS:
+    case TokenID.SET_SYMMETRIC_MINUS:
+    case TokenID.ASSIGN:
+    case TokenID.ITERATE:
+      return labelToken(node.typeID);
+  }
+  if (node.data.value) {
+    return node.data.value;
+  }
+  return "UNKNOWN NODE: " + String(node.typeID);
+}
+function labelType(type) {
+  if (!type) {
+    return "N/A";
+  }
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+      return ANY_TYPE_NAME;
+    case TypeID.integer:
+      return INTEGER_TYPE_NAME;
+    case TypeID.basic:
+      return type.baseID;
+    case TypeID.tuple:
+      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)).join("\xD7");
+    case TypeID.collection:
+      return type.base.typeID === TypeID.collection ? `\u212C${labelType(type.base)}` : `\u212C(${labelType(type.base)})`;
+    case TypeID.logic:
+      return LOGIC_TYPE_NAME;
+    case TypeID.predicate:
+    case TypeID.function:
+      const argsText = type.args.map((arg) => labelType(arg.type)).join(", ");
+      return `[${argsText}] \u2192 ${labelType(type.result)}`;
+  }
+}
+
+// src/rslang/semantic/typification-api.ts
+var TypeIDToClass = {
+  [TypeID.anyTypification]: TypeClass.typification,
+  [TypeID.integer]: TypeClass.typification,
+  [TypeID.basic]: TypeClass.typification,
+  [TypeID.tuple]: TypeClass.typification,
+  [TypeID.collection]: TypeClass.typification,
+  [TypeID.logic]: TypeClass.logic,
+  [TypeID.function]: TypeClass.function,
+  [TypeID.predicate]: TypeClass.predicate
+};
+function hasGenerics(type) {
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+      return true;
+    case TypeID.integer:
+      return false;
+    case TypeID.basic:
+      return isRadical(type.baseID);
+    case TypeID.collection:
+      return hasGenerics(type.base);
+    case TypeID.tuple:
+      for (const factor of type.factors) {
+        if (hasGenerics(factor)) {
+          return true;
+        }
+      }
+      return false;
+  }
+}
+function checkEquality(type1, type2) {
+  if (type1 === type2) {
+    return true;
+  }
+  if (type1.typeID !== type2.typeID) {
+    return false;
+  }
+  switch (type1.typeID) {
+    case TypeID.integer:
+    case TypeID.anyTypification:
+      return true;
+    case TypeID.basic:
+      return type1.baseID === type2.baseID;
+    case TypeID.collection:
+      return checkEquality(type1.base, type2.base);
+    case TypeID.tuple: {
+      if (type1.factors.length !== type2.factors.length) {
+        return false;
+      }
+      for (let index = 0; index < type1.factors.length; ++index) {
+        if (!checkEquality(type1.factors[index], type2.factors[index])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+function mergeTypifications(type1, type2) {
+  if (type1 === type2) {
+    return type1;
+  }
+  if (type1.typeID === TypeID.anyTypification) {
+    return isTypification(type2) ? type2 : null;
+  }
+  if (type2.typeID === TypeID.anyTypification) {
+    return isTypification(type1) ? type1 : null;
+  }
+  switch (type1.typeID) {
+    case TypeID.integer:
+    case TypeID.basic:
+      return commonType(type1, type2);
+    case TypeID.collection:
+      if (type2.typeID !== TypeID.collection) {
+        return null;
+      }
+      const base = mergeTypifications(type1.base, type2.base);
+      return base ? bool(base) : null;
+    case TypeID.tuple:
+      if (type2.typeID !== TypeID.tuple) {
+        return null;
+      }
+      if (type1.factors.length !== type2.factors.length) {
+        return null;
+      }
+      const components = [];
+      for (let index = 0; index < type1.factors.length; ++index) {
+        const component2 = mergeTypifications(type1.factors[index], type2.factors[index]);
+        if (component2 === null) {
+          return null;
+        }
+        components.push(component2);
+      }
+      return tuple(components);
+  }
+}
+function checkCompatibility(type1, type2) {
+  if (type1 === type2) {
+    return true;
+  }
+  if (type1.typeID === TypeID.anyTypification) {
+    return isTypification(type2);
+  }
+  if (type2.typeID === TypeID.anyTypification) {
+    return isTypification(type1);
+  }
+  if (isTypification(type1) !== isTypification(type2)) {
+    return false;
+  }
+  if (type1.typeID === TypeID.integer || type1.typeID === TypeID.basic || type2.typeID === TypeID.integer || type2.typeID === TypeID.basic) {
+    return commonType(type1, type2) !== null;
+  }
+  if (type1.typeID !== type2.typeID) {
+    return false;
+  }
+  switch (type1.typeID) {
+    case TypeID.collection:
+      return checkCompatibility(type1.base, type2.base);
+    case TypeID.tuple:
+      if (type1.factors.length !== type2.factors.length) {
+        return false;
+      }
+      for (let index = 0; index < type1.factors.length; ++index) {
+        if (!checkCompatibility(type1.factors[index], type2.factors[index])) {
+          return false;
+        }
+      }
+      return true;
+    case TypeID.logic:
+    case TypeID.predicate:
+    case TypeID.function:
+      return false;
+  }
+}
+function compareTemplated(substitutes, arg, value) {
+  if (arg === value) {
+    return true;
+  }
+  if (arg.typeID === TypeID.basic && isRadical(arg.baseID)) {
+    if (!substitutes.has(arg.baseID)) {
+      substitutes.set(arg.baseID, value);
+      return true;
+    } else {
+      const mergeType = mergeTypifications(substitutes.get(arg.baseID), value);
+      if (mergeType === null) {
+        return false;
+      }
+      substitutes.set(arg.baseID, mergeType);
+      return true;
+    }
+  }
+  if (value.typeID === TypeID.anyTypification) {
+    return true;
+  }
+  if (arg.typeID === TypeID.integer || arg.typeID === TypeID.basic || value.typeID === TypeID.integer || value.typeID === TypeID.basic) {
+    return commonType(arg, value) !== null;
+  }
+  if (arg.typeID !== value.typeID) {
+    return false;
+  }
+  switch (arg.typeID) {
+    case TypeID.collection:
+      return compareTemplated(substitutes, arg.base, value.base);
+    case TypeID.tuple: {
+      if (arg.factors.length !== value.factors.length) {
+        return false;
+      }
+      for (let index = 0; index < arg.factors.length; ++index) {
+        if (!compareTemplated(substitutes, arg.factors[index], value.factors[index])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+function substituteBase(target, substitutes) {
+  switch (target.typeID) {
+    case TypeID.basic: {
+      if (substitutes.has(target.baseID)) {
+        Object.assign(target, substitutes.get(target.baseID));
+      }
+      return;
+    }
+    case TypeID.collection: {
+      substituteBase(target.base, substitutes);
+      return;
+    }
+    case TypeID.tuple: {
+      for (const factor of target.factors) {
+        substituteBase(factor, substitutes);
+      }
+      return;
+    }
+  }
+}
+function commonType(type1, type2) {
+  if (type1 === type2) {
+    return type1;
+  }
+  const int1 = "isIntegerCompatible" in type1 && type1.isIntegerCompatible;
+  const int2 = "isIntegerCompatible" in type2 && type2.isIntegerCompatible;
+  if (!int1 || !int2) {
+    if (type1.typeID === TypeID.basic && type2.typeID === TypeID.basic) {
+      return type1.baseID === type2.baseID ? type1 : null;
+    }
+    return null;
+  }
+  if (type1.typeID === TypeID.integer) {
+    return type2;
+  } else if (type2.typeID === TypeID.integer) {
+    return type1;
+  } else {
+    return IntegerT;
+  }
+}
+
+// src/rslang/semantic/type-auditor.ts
+var TypeAuditor = class _TypeAuditor {
+  static TYPE_DEDUCTION_DEPTH = 5;
+  context;
+  reporter;
+  locals;
+  annotateTypes;
+  annotateErrors;
+  constructor(context) {
+    this.annotateTypes = false;
+    this.annotateErrors = false;
+    this.context = context;
+    this.locals = new LocalContext(this.onError.bind(this));
+  }
+  run(ast, annotateTypes, reporter, annotateErrors = false) {
+    if (ast.hasError) {
+      return null;
+    }
+    this.annotateTypes = annotateTypes;
+    this.annotateErrors = annotateErrors;
+    this.reporter = reporter;
+    this.clear();
+    return this.dispatchVisit(ast);
+  }
+  clear() {
+    this.locals = new LocalContext(this.onError.bind(this));
+  }
+  dispatchDeclare(node, domain) {
+    const result = this.processDeclare(node, domain);
+    if (result === true && this.annotateTypes) {
+      annotateType(node, domain);
+    }
+    return result;
+  }
+  processDeclare(node, domain) {
+    switch (node.typeID) {
+      case TokenID.ID_LOCAL:
+        return this.declareLocal(node, domain);
+      case TokenID.NT_TUPLE_DECL:
+        return this.declareTuple(node, domain);
+      case TokenID.NT_ENUM_DECL:
+        return this.declareEnumeration(node, domain);
+    }
+    return false;
+  }
+  declareLocal(node, domain) {
+    return this.locals.pushLocal(node, domain);
+  }
+  declareTuple(node, domain) {
+    if (domain.typeID !== TypeID.tuple || domain.factors.length !== node.children.length) {
+      this.onError(RSErrorCode.invalidCortegeDeclare, node.children[0]);
+      return false;
+    }
+    for (let child = 0; child < node.children.length; child++) {
+      if (!this.visitChildDeclaration(node, child, component(domain, child + 1))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  declareEnumeration(node, domain) {
+    for (const child of node.children) {
+      if (!this.dispatchDeclare(child, domain)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  dispatchVisit(node) {
+    const result = this.processVisit(node);
+    if (result !== null && this.annotateTypes) {
+      annotateType(node, result);
+    }
+    return result;
+  }
+  processVisit(node) {
+    switch (node.typeID) {
+      case TokenID.ID_GLOBAL:
+      case TokenID.ID_FUNCTION:
+      case TokenID.ID_PREDICATE:
+        return this.visitGlobal(node);
+      case TokenID.ID_LOCAL:
+        return this.visitLocal(node);
+      case TokenID.ID_RADICAL:
+        return this.visitRadical(node);
+      case TokenID.LIT_INTEGER:
+        return IntegerT;
+      case TokenID.LIT_WHOLE_NUMBERS:
+        return bool(IntegerT);
+      case TokenID.LIT_EMPTYSET:
+        return this.visitEmptySet(node);
+      case TokenID.NT_ARGUMENTS:
+        return this.visitArgumentsEnum(node);
+      case TokenID.NT_ARG_DECL:
+        return this.visitArgument(node);
+      case TokenID.PLUS:
+      case TokenID.MINUS:
+      case TokenID.MULTIPLY:
+        return this.visitArithmetic(node);
+      case TokenID.QUANTOR_UNIVERSAL:
+      case TokenID.QUANTOR_EXISTS:
+        return this.visitQuantifier(node);
+      case TokenID.LOGIC_NOT:
+        return this.visitNegation(node);
+      case TokenID.LOGIC_AND:
+      case TokenID.LOGIC_OR:
+      case TokenID.LOGIC_IMPLICATION:
+      case TokenID.LOGIC_EQUIVALENT:
+        return this.visitLogicBinary(node);
+      case TokenID.EQUAL:
+      case TokenID.NOTEQUAL:
+        return this.visitEquals(node);
+      case TokenID.GREATER:
+      case TokenID.LESSER:
+      case TokenID.GREATER_OR_EQ:
+      case TokenID.LESSER_OR_EQ:
+        return this.visitIntegerPredicate(node);
+      case TokenID.SET_IN:
+      case TokenID.SET_NOT_IN:
+      case TokenID.SUBSET:
+      case TokenID.SUBSET_OR_EQ:
+      case TokenID.NOT_SUBSET:
+        return this.visitSetexprPredicate(node);
+      case TokenID.DECART:
+        return this.visitDecart(node);
+      case TokenID.BOOLEAN:
+        return this.visitBoolean(node);
+      case TokenID.NT_TUPLE:
+        return this.visitTuple(node);
+      case TokenID.NT_ENUMERATION:
+        return this.visitEnumeration(node);
+      case TokenID.BIGPR:
+        return this.visitProjectSet(node);
+      case TokenID.SMALLPR:
+        return this.visitProjectTuple(node);
+      case TokenID.FILTER:
+        return this.visitFilter(node);
+      case TokenID.CARD:
+        return this.visitCard(node);
+      case TokenID.REDUCE:
+        return this.visitReduce(node);
+      case TokenID.BOOL:
+        return this.visitBool(node);
+      case TokenID.DEBOOL:
+        return this.visitDebool(node);
+      case TokenID.SET_UNION:
+      case TokenID.SET_INTERSECTION:
+      case TokenID.SET_MINUS:
+      case TokenID.SET_SYMMETRIC_MINUS:
+        return this.visitSetexprBinary(node);
+      case TokenID.NT_FUNC_DEFINITION:
+        return this.visitFunctionDefinition(node);
+      case TokenID.NT_FUNC_CALL:
+        return this.visitFunctionCall(node);
+      case TokenID.ITERATE:
+        return this.visitIterate(node);
+      case TokenID.ASSIGN:
+        return this.visitAssign(node);
+      case TokenID.NT_DECLARATIVE_EXPR:
+        return this.visitDeclarative(node);
+      case TokenID.NT_IMPERATIVE_EXPR:
+        return this.visitImperative(node);
+      case TokenID.NT_RECURSIVE_FULL:
+      case TokenID.NT_RECURSIVE_SHORT:
+        return this.visitRecursion(node);
+    }
+    return null;
+  }
+  onError(code, node, params) {
+    this.reporter?.({ code, from: node.from, to: node.to, params });
+    if (this.annotateErrors) {
+      annotateError(node, code, params);
+    }
+    return null;
+  }
+  visitChild(node, index) {
+    if (index >= node.children.length) {
+      return null;
+    }
+    return this.dispatchVisit(node.children[index]);
+  }
+  visitChildDeclaration(node, index, domain) {
+    if (index >= node.children.length) {
+      return false;
+    }
+    if (!this.dispatchDeclare(node.children[index], domain)) {
+      return false;
+    }
+    return true;
+  }
+  visitAllAndReturn(node, type) {
+    for (const child of node.children) {
+      if (!this.dispatchVisit(child)) {
+        return null;
+      }
+    }
+    return type;
+  }
+  childTypification(node, index) {
+    const result = this.visitChild(node, index);
+    if (result === null) {
+      return null;
+    }
+    if (!isTypification(result)) {
+      this.onError(RSErrorCode.expectedSetexpr, node.children[index], [labelType(result)]);
+      return null;
+    }
+    return result;
+  }
+  childLogic(node, index) {
+    const result = this.visitChild(node, index);
+    if (result === null) {
+      return false;
+    }
+    if (result.typeID !== TypeID.logic) {
+      this.onError(RSErrorCode.expectedLogic, node.children[index], [labelType(result)]);
+      return false;
+    }
+    return true;
+  }
+  childTypeDebool(node, index, errorCode) {
+    const result = this.childTypification(node, index);
+    if (result === null) {
+      return null;
+    }
+    if (result.typeID === TypeID.anyTypification) {
+      return result;
+    }
+    if (result.typeID !== TypeID.collection) {
+      this.onError(errorCode, node.children[index], [labelType(result)]);
+      return null;
+    }
+    return debool(result);
+  }
+  visitLocal(node) {
+    return this.locals.getLocalType(node);
+  }
+  visitGlobal(node) {
+    const alias = getNodeText(node);
+    const type = this.context.get(alias);
+    if (!type) {
+      return this.onError(RSErrorCode.globalNotTyped, node, [alias]);
+    }
+    return type;
+  }
+  visitFunctionDefinition(node) {
+    this.locals.startScope();
+    if (!this.visitChild(node, 0)) {
+      return null;
+    }
+    const args = [];
+    for (const local of this.locals.data) {
+      if (local.level === 1) {
+        args.push({ alias: local.alias, type: local.type });
+      }
+    }
+    const result = this.visitChild(node, 1);
+    if (result === null || result.typeID === TypeID.function || result.typeID === TypeID.predicate) {
+      return null;
+    }
+    this.locals.endScope(node.children[1]);
+    if (result.typeID === TypeID.logic) {
+      return {
+        typeID: TypeID.predicate,
+        result,
+        args
+      };
+    } else {
+      return {
+        typeID: TypeID.function,
+        result,
+        args
+      };
+    }
+  }
+  visitFunctionCall(node) {
+    const funcName = getNodeText(node.children[0]);
+    const funcType = this.context.get(funcName);
+    if (funcType?.typeID !== TypeID.function && funcType?.typeID !== TypeID.predicate) {
+      return this.onError(RSErrorCode.globalNotTyped, node.children[0], [funcName]);
+    }
+    if (this.annotateTypes) {
+      annotateType(node.children[0], funcType);
+    }
+    const substitutes = this.checkFuncArguments(node, funcName, funcType);
+    if (substitutes === null) {
+      return null;
+    }
+    if (funcType.result.typeID === TypeID.logic) {
+      return funcType.result;
+    } else {
+      const result = mangleRadicals(funcName, funcType.result);
+      if (substitutes.size > 0) {
+        substituteBase(result, substitutes);
+      }
+      return result;
+    }
+  }
+  visitRadical(node) {
+    const alias = getNodeText(node);
+    if (!this.isInsideFuncArgument(node)) {
+      return this.onError(RSErrorCode.radicalUsage, node, [alias]);
+    }
+    return bool({ typeID: TypeID.basic, baseID: alias });
+  }
+  visitEmptySet(node) {
+    const invalidParents = [
+      TokenID.CARD,
+      TokenID.DEBOOL,
+      TokenID.SET_UNION,
+      TokenID.SET_INTERSECTION,
+      TokenID.SET_MINUS,
+      TokenID.SET_SYMMETRIC_MINUS,
+      TokenID.REDUCE,
+      TokenID.BIGPR,
+      TokenID.SMALLPR
+    ];
+    if (invalidParents.includes(node.parent?.typeID)) {
+      return this.onError(RSErrorCode.invalidEmptySetUsage, node);
+    }
+    return EmptySetT;
+  }
+  visitArgument(node) {
+    const variable = node.children[0];
+    if (variable.typeID === TokenID.NT_TUPLE_DECL) {
+      return this.onError(RSErrorCode.invalidArgumentCortegeDeclare, variable);
+    }
+    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    if (domain === null) {
+      return null;
+    }
+    if (!this.visitChildDeclaration(node, 0, domain)) {
+      return null;
+    }
+    return domain;
+  }
+  visitCard(node) {
+    if (!this.childTypeDebool(node, 0, RSErrorCode.invalidCard)) {
+      return null;
+    }
+    return IntegerT;
+  }
+  visitArithmetic(node) {
+    const type1 = this.childTypification(node, 0);
+    if (type1 === null) {
+      return null;
+    }
+    if (!("isArithmetic" in type1 && type1.isArithmetic)) {
+      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[0], [labelType(type1)]);
+    }
+    const type2 = this.childTypification(node, 1);
+    if (type2 === null) {
+      return null;
+    }
+    if (!("isArithmetic" in type2 && type2.isArithmetic)) {
+      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[1], [labelType(type2)]);
+    }
+    const result = mergeTypifications(type1, type2);
+    if (result === null) {
+      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
+    }
+    return result;
+  }
+  visitIntegerPredicate(node) {
+    const type1 = this.childTypification(node, 0);
+    if (type1 === null) {
+      return null;
+    }
+    if (!("isOrdered" in type1 && type1.isOrdered)) {
+      return this.onError(RSErrorCode.orderingNotSupported, node.children[0], [labelType(type1)]);
+    }
+    const type2 = this.childTypification(node, 1);
+    if (type2 === null) {
+      return null;
+    }
+    if (!("isOrdered" in type2 && type2.isOrdered)) {
+      return this.onError(RSErrorCode.orderingNotSupported, node.children[1], [labelType(type2)]);
+    }
+    if (!checkCompatibility(type1, type2)) {
+      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
+    }
+    return LogicT;
+  }
+  visitQuantifier(node) {
+    this.locals.startScope();
+    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    if (domain === null) {
+      return null;
+    } else if (!this.visitChildDeclaration(node, 0, domain)) {
+      return null;
+    } else if (!this.childLogic(node, 2)) {
+      return null;
+    }
+    this.locals.endScope(node.children[2]);
+    return LogicT;
+  }
+  visitNegation(node) {
+    if (!this.childLogic(node, 0)) {
+      return null;
+    }
+    return LogicT;
+  }
+  visitLogicBinary(node) {
+    if (!this.childLogic(node, 0) || !this.childLogic(node, 1)) {
+      return null;
+    }
+    return LogicT;
+  }
+  visitEquals(node) {
+    const type1 = this.childTypification(node, 0);
+    if (type1 === null) {
+      return null;
+    }
+    const type2 = this.childTypification(node, 1);
+    if (type2 === null) {
+      return null;
+    }
+    if (!checkCompatibility(type1, type2)) {
+      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
+    }
+    return LogicT;
+  }
+  visitSetexprPredicate(node) {
+    let type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    if (type2 === null) {
+      return null;
+    }
+    const isSubset = this.isSubset(node.typeID);
+    if (isSubset) {
+      type2 = bool(type2);
+    }
+    const type1 = this.childTypification(node, 0);
+    if (type1 === null) {
+      return null;
+    }
+    if (!checkCompatibility(type1, type2)) {
+      if (isSubset) {
+        return this.onError(RSErrorCode.typesNotEqual, node, [labelType(type1), labelType(type2)]);
+      } else {
+        return this.onError(RSErrorCode.invalidElementPredicate, node, [
+          labelType(type1),
+          labelToken(node.typeID),
+          labelType(bool(type2))
+        ]);
+      }
+    }
+    return LogicT;
+  }
+  visitDecart(node) {
+    const factors = [];
+    for (let child = 0; child < node.children.length; child++) {
+      const type = this.childTypeDebool(node, child, RSErrorCode.invalidDecart);
+      if (type === null) {
+        return null;
+      } else {
+        factors.push(type);
+      }
+    }
+    return bool(tuple(factors));
+  }
+  visitBoolean(node) {
+    const type = this.childTypeDebool(node, 0, RSErrorCode.invalidBoolean);
+    if (type === null) {
+      return null;
+    }
+    return bool(bool(type));
+  }
+  visitTuple(node) {
+    const components = [];
+    for (let child = 0; child < node.children.length; child++) {
+      const type = this.childTypification(node, child);
+      if (type === null) {
+        return null;
+      }
+      components.push(type);
+    }
+    return tuple(components);
+  }
+  visitEnumeration(node) {
+    let type = this.childTypification(node, 0);
+    if (type === null) {
+      return null;
+    }
+    for (let child = 1; child < node.children.length; child++) {
+      const childType = this.childTypification(node, child);
+      if (childType === null) {
+        return null;
+      }
+      const merge = mergeTypifications(type, childType);
+      if (merge === null) {
+        return this.onError(RSErrorCode.invalidEnumeration, node.children[child], [
+          labelType(type),
+          labelType(childType)
+        ]);
+      }
+      type = merge;
+    }
+    return bool(type);
+  }
+  visitBool(node) {
+    return this.visitEnumeration(node);
+  }
+  visitDebool(node) {
+    return this.childTypeDebool(node, 0, RSErrorCode.invalidDebool);
+  }
+  visitSetexprBinary(node) {
+    const type1 = this.childTypeDebool(node, 0, RSErrorCode.invalidTypeOperation);
+    if (type1 === null) {
+      return null;
+    }
+    const type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    if (type2 === null) {
+      return null;
+    }
+    const result = mergeTypifications(type1, type2);
+    if (result === null) {
+      return this.onError(RSErrorCode.typesNotEqual, node, [labelType(bool(type1)), labelType(bool(type2))]);
+    }
+    return bool(result);
+  }
+  visitProjectSet(node) {
+    const argument = this.childTypeDebool(node, 0, RSErrorCode.invalidProjectionSet);
+    if (argument === null) {
+      return null;
+    }
+    if (argument.typeID === TypeID.anyTypification) {
+      return EmptySetT;
+    }
+    if (argument.typeID !== TypeID.tuple) {
+      return this.onError(RSErrorCode.invalidProjectionSet, node.children[0], [
+        labelRSLangNode(node),
+        labelType(bool(argument))
+      ]);
+    }
+    const indices = getNodeIndices(node);
+    const components = [];
+    for (const index of indices) {
+      const newComponent = component(argument, index);
+      if (newComponent === null) {
+        return this.onError(RSErrorCode.invalidProjectionSet, node.children[0], [
+          labelRSLangNode(node),
+          labelType(bool(argument))
+        ]);
+      } else {
+        components.push(newComponent);
+      }
+    }
+    if (components.length === 1) {
+      return bool(components[0]);
+    } else {
+      return bool(tuple(components));
+    }
+  }
+  visitProjectTuple(node) {
+    const argument = this.childTypification(node, 0);
+    if (argument === null) {
+      return null;
+    }
+    if (argument.typeID === TypeID.anyTypification) {
+      return argument;
+    }
+    if (argument.typeID !== TypeID.tuple) {
+      return this.onError(RSErrorCode.invalidProjectionTuple, node.children[0], [
+        labelRSLangNode(node),
+        labelType(argument)
+      ]);
+    }
+    const indices = getNodeIndices(node);
+    const components = [];
+    for (const index of indices) {
+      const newComponent = component(argument, index);
+      if (newComponent === null) {
+        return this.onError(RSErrorCode.invalidProjectionTuple, node.children[0], [
+          labelRSLangNode(node),
+          labelType(argument)
+        ]);
+      } else {
+        components.push(newComponent);
+      }
+    }
+    if (components.length === 1) {
+      return components[0];
+    } else {
+      return tuple(components);
+    }
+  }
+  visitFilter(node) {
+    const indices = getNodeIndices(node);
+    const tupleParam = indices.length === node.children.length - 1;
+    if (!tupleParam && node.children.length > 2) {
+      return this.onError(RSErrorCode.invalidFilterArity, node);
+    }
+    const argument = this.childTypification(node, node.children.length - 1);
+    if (argument === null) {
+      return null;
+    }
+    if (argument.typeID === TypeID.anyTypification || argument.typeID === TypeID.collection && argument.base.typeID === TypeID.anyTypification) {
+      return EmptySetT;
+    }
+    if (argument.typeID !== TypeID.collection || argument.base.typeID !== TypeID.tuple) {
+      return this.onError(RSErrorCode.invalidFilterArgumentType, node.children[node.children.length - 1], [
+        labelRSLangNode(node),
+        labelType(argument)
+      ]);
+    }
+    const argBase = debool(argument);
+    const bases = [];
+    for (const index of indices) {
+      const newBase = component(argBase, index);
+      if (newBase === null) {
+        return this.onError(RSErrorCode.invalidFilterArgumentType, node.children[node.children.length - 1], [
+          labelRSLangNode(node),
+          labelType(argument)
+        ]);
+      }
+      bases.push(newBase);
+    }
+    if (tupleParam) {
+      for (let child = 0; child + 1 < node.children.length; child++) {
+        const param = this.childTypification(node, child);
+        if (param === null) {
+          return null;
+        }
+        if (param.typeID !== TypeID.collection || !checkCompatibility(bases[child], debool(param))) {
+          return this.onError(RSErrorCode.typesNotEqual, node.children[child], [
+            labelType(param),
+            labelType(bool(bases[child]))
+          ]);
+        }
+      }
+    } else {
+      const param = this.childTypification(node, 0);
+      if (param === null) {
+        return null;
+      }
+      const paramType = param;
+      const expected = bool(tuple(bases));
+      if (paramType.typeID !== TypeID.collection || !checkCompatibility(expected, paramType)) {
+        return this.onError(RSErrorCode.typesNotEqual, node.children[0], [labelType(paramType), labelType(expected)]);
+      }
+    }
+    return argument;
+  }
+  visitReduce(node) {
+    const argument = this.childTypification(node, 0);
+    if (argument === null) {
+      return null;
+    }
+    if (argument.typeID === TypeID.anyTypification || argument.typeID === TypeID.collection && argument.base.typeID === TypeID.anyTypification) {
+      return EmptySetT;
+    }
+    if (argument.typeID !== TypeID.collection || argument.base.typeID !== TypeID.collection) {
+      return this.onError(RSErrorCode.invalidReduce, node.children[0], [labelType(argument)]);
+    }
+    return debool(argument);
+  }
+  visitArgumentsEnum(node) {
+    return this.visitAllAndReturn(node, LogicT);
+  }
+  visitDeclarative(node) {
+    this.locals.startScope();
+    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    if (domain === null) {
+      return null;
+    } else if (!this.visitChildDeclaration(node, 0, domain)) {
+      return null;
+    } else if (!this.childLogic(node, 2)) {
+      return null;
+    }
+    this.locals.endScope(node.children[2]);
+    return bool(domain);
+  }
+  visitImperative(node) {
+    this.locals.startScope();
+    for (let child = 1; child < node.children.length; child++) {
+      if (!this.childLogic(node, child)) {
+        return null;
+      }
+    }
+    const type = this.childTypification(node, 0);
+    if (type === null) {
+      return null;
+    }
+    this.locals.endScope(node);
+    return bool(type);
+  }
+  visitIterate(node) {
+    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
+    if (domain === null) {
+      return null;
+    }
+    if (!this.visitChildDeclaration(node, 0, domain)) {
+      return null;
+    }
+    return LogicT;
+  }
+  visitAssign(node) {
+    const domain = this.childTypification(node, 1);
+    if (domain === null) {
+      return null;
+    }
+    if (!this.visitChildDeclaration(node, 0, domain)) {
+      return null;
+    }
+    return LogicT;
+  }
+  visitRecursion(node) {
+    this.locals.startScope();
+    const initType = this.childTypification(node, 1);
+    if (initType === null) {
+      return null;
+    }
+    if (!this.visitChildDeclaration(node, 0, initType)) {
+      return null;
+    }
+    const isFull = node.typeID === TokenID.NT_RECURSIVE_FULL;
+    const iterationIndex = isFull ? 3 : 2;
+    let iterationValue = this.childTypification(node, iterationIndex);
+    if (iterationValue === null) {
+      return null;
+    }
+    if (!checkCompatibility(iterationValue, initType)) {
+      return this.onError(RSErrorCode.typesNotEqual, node.children[iterationIndex], [
+        labelType(iterationValue),
+        labelType(initType)
+      ]);
+    }
+    if (hasGenerics(initType)) {
+      for (let retries = _TypeAuditor.TYPE_DEDUCTION_DEPTH; retries > 0; retries--) {
+        this.locals.endScope(node);
+        this.locals.clearUnused();
+        this.locals.startScope();
+        if (!this.visitChildDeclaration(node, 0, iterationValue)) {
+          return null;
+        }
+        const newIteration = this.childTypification(node, iterationIndex);
+        if (newIteration === null) {
+          return null;
+        }
+        if (checkEquality(newIteration, iterationValue)) {
+          break;
+        }
+        iterationValue = newIteration;
+      }
+    }
+    if (isFull) {
+      if (!this.childLogic(node, 2)) {
+        return null;
+      }
+    }
+    this.locals.endScope(node);
+    return iterationValue;
+  }
+  isSubset(token) {
+    return token === TokenID.SUBSET || token === TokenID.SUBSET_OR_EQ || token === TokenID.NOT_SUBSET;
+  }
+  isInsideFuncArgument(node) {
+    while (node.parent && node.parent !== node) {
+      if (node.typeID === TokenID.NT_ARGUMENTS) return true;
+      node = node.parent;
+    }
+    return false;
+  }
+  checkFuncArguments(node, alias, type) {
+    if (node.children.length - 1 !== type.args.length) {
+      return this.onError(RSErrorCode.invalidArgsArity, node.children[1], [
+        String(type.args.length),
+        String(node.children.length - 1)
+      ]);
+    }
+    const substitutes = /* @__PURE__ */ new Map();
+    for (let child = 1; child < node.children.length; child++) {
+      const childType = this.childTypification(node, child);
+      if (childType === null) {
+        return null;
+      }
+      const argType = mangleRadicals(alias, type.args[child - 1].type);
+      if (!compareTemplated(substitutes, argType, childType)) {
+        this.onError(RSErrorCode.invalidArgumentType, node.children[child], [
+          `${type.args[child - 1].alias}\u2208${labelType(argType)}`,
+          labelType(childType)
+        ]);
+        return null;
+      }
+    }
+    return substitutes;
+  }
+};
+function mangleRadicals(funcName, type) {
+  switch (type.typeID) {
+    default:
+      throw new Error(`Unexpected type: ${type.typeID}`);
+    case TypeID.integer:
+      return type;
+    case TypeID.basic: {
+      if (isRadical(type.baseID)) {
+        return {
+          typeID: type.typeID,
+          baseID: type.baseID + funcName
+        };
+      }
+      return type;
+    }
+    case TypeID.collection: {
+      return {
+        typeID: type.typeID,
+        base: mangleRadicals(funcName, debool(type))
+      };
+    }
+    case TypeID.tuple: {
+      const factors = [];
+      for (let index = 1; index <= type.factors.length; ++index) {
+        factors.push(mangleRadicals(funcName, component(type, index)));
+      }
+      return {
+        typeID: type.typeID,
+        factors
+      };
+    }
+  }
+}
+var LocalContext = class {
+  onError;
+  data = [];
+  constructor(onError) {
+    this.onError = onError;
+  }
+  startScope() {
+    for (const local of this.data) {
+      if (local.level > 0) {
+        local.level = local.level + 1;
+      }
+    }
+  }
+  endScope(node, skipUnused = false) {
+    for (const local of this.data) {
+      local.level--;
+      if (!skipUnused && local.level === 0 && local.useCount === 0) {
+        this.onError(RSErrorCode.localNotUsed, node, [local.alias]);
+      }
+    }
+  }
+  clearUnused() {
+    this.data = this.data.filter((data) => data.level > 0);
+  }
+  pushLocal(node, type) {
+    const alias = getNodeText(node);
+    const existing = this.data.find((data) => data.alias === alias);
+    if (existing) {
+      if (existing.level > 0) {
+        this.onError(RSErrorCode.localShadowing, node, [alias]);
+        return false;
+      } else {
+        this.onError(RSErrorCode.localDoubleDeclare, node, [alias]);
+        const index = this.data.indexOf(existing);
+        if (index !== -1) {
+          this.data.splice(index, 1);
+        }
+      }
+    }
+    this.data.push({ alias, type, level: 1, useCount: 0 });
+    return true;
+  }
+  getLocalType(node) {
+    const alias = getNodeText(node);
+    const local = this.data.find((data) => data.alias === alias);
+    if (local === void 0) {
+      this.onError(RSErrorCode.localUndeclared, node, [alias]);
+      return null;
+    } else if (local.level < 1) {
+      this.onError(RSErrorCode.localOutOfScope, node, [alias]);
+      return null;
+    } else {
+      local.useCount++;
+      return local.type;
+    }
+  }
+};
+export {
+  TypeAuditor
+};
+//# sourceMappingURL=type-auditor.js.map