@rsconcept/domain 1.0.0 → 1.2.0

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

@@ -1,1570 +1,600 @@
-// 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;
-  }
+import { annotateError, annotateType } from "../ast-annotations.js";
+import { RSErrorCode } from "../error.js";
+import { getNodeIndices, getNodeText } from "../../parsing/ast.js";
+import "../../parsing/index.js";
+import { TokenID } from "../parser/token.js";
+import { EmptySetT, IntegerT, LogicT, TypeID, bool, component, debool, isRadical, isTypification, tuple } from "./typification.js";
+import { labelRSLangNode, labelToken, labelType } from "../labels.js";
+import { checkCompatibility, checkEquality, compareTemplated, hasGenerics, mergeTypifications, substituteBase } from "./typification-api.js";
+//#region src/rslang/semantic/type-auditor.ts
+/**
+* Module: Type auditor for AST type checking.
+*/
+/** Type auditor for AST type checking. */
+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) {
+		if ([
+			TokenID.CARD,
+			TokenID.DEBOOL,
+			TokenID.SET_UNION,
+			TokenID.SET_INTERSECTION,
+			TokenID.SET_MINUS,
+			TokenID.SET_SYMMETRIC_MINUS,
+			TokenID.REDUCE,
+			TokenID.BIGPR,
+			TokenID.SMALLPR
+		].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}∈${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
-      };
-    }
-  }
+	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
+			};
+		}
+	}
 }
+/** Local variables context. */
 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
+	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;
+		}
+	}
 };
+//#endregion
+export { TypeAuditor };
+
 //# sourceMappingURL=type-auditor.js.map