@tuprolog/2p-full 0.30.5-dev01 → 0.31.1

package/2p-parser-core.js

@@ -0,0 +1,1450 @@
+(function (_, $module$_tuprolog_parser_utils_xy31vy, $module$antlr4, $module$antlr4_src_antlr4_error_s9pni7, $module$antlr4_src_antlr4_atn_66gh9q, kotlin_kotlin, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_parser_js, kotlin_kt_math) {
+  'use strict';
+  //region block: imports
+  var PrologParserListener = $module$_tuprolog_parser_utils_xy31vy.PrologParserListener;
+  var Associativity = $module$_tuprolog_parser_utils_xy31vy.Associativity;
+  var Token = $module$antlr4.Token;
+  var RecognitionException = $module$antlr4_src_antlr4_error_s9pni7.RecognitionException;
+  var PredictionMode = $module$antlr4_src_antlr4_atn_66gh9q.PredictionMode;
+  var PrologParser = $module$_tuprolog_parser_utils_xy31vy.PrologParser;
+  var InputStream = $module$antlr4.InputStream;
+  var PrologLexer = $module$_tuprolog_parser_utils_xy31vy.PrologLexer;
+  var CommonTokenStream = $module$antlr4.CommonTokenStream;
+  var BailErrorStrategy = $module$antlr4_src_antlr4_error_s9pni7.BailErrorStrategy;
+  var PrologParserVisitor = $module$_tuprolog_parser_utils_xy31vy.PrologParserVisitor;
+  var captureStack = kotlin_kotlin.$_$.h6;
+  var classMeta = kotlin_kotlin.$_$.m6;
+  var setMetadataFor = kotlin_kotlin.$_$.j7;
+  var TuPrologException = kotlin_it_unibo_tuprolog_core.$_$.l1;
+  var TuPrologException_init_$Init$ = kotlin_it_unibo_tuprolog_core.$_$.m;
+  var ensureNotNull = kotlin_kotlin.$_$.vb;
+  var replace$default = kotlin_kotlin.$_$.r;
+  var _Char___init__impl__6a9atx = kotlin_kotlin.$_$.d2;
+  var Char = kotlin_kotlin.$_$.eb;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.c1;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.q;
+  var OperatorSet_init_$Create$ = kotlin_it_unibo_tuprolog_core.$_$.n;
+  var objectMeta = kotlin_kotlin.$_$.i7;
+  var Struct = kotlin_it_unibo_tuprolog_core.$_$.z1;
+  var isInterface = kotlin_kotlin.$_$.y6;
+  var getKClass = kotlin_kotlin.$_$.c;
+  var Unit_getInstance = kotlin_kotlin.$_$.r2;
+  var Constant = kotlin_it_unibo_tuprolog_core.$_$.q1;
+  var Var = kotlin_it_unibo_tuprolog_core.$_$.b3;
+  var Atom = kotlin_it_unibo_tuprolog_core.$_$.o1;
+  var Numeric = kotlin_it_unibo_tuprolog_core.$_$.w1;
+  var Integer = kotlin_it_unibo_tuprolog_core.$_$.u1;
+  var Real = kotlin_it_unibo_tuprolog_core.$_$.x1;
+  var Clause = kotlin_it_unibo_tuprolog_core.$_$.p1;
+  var Rule = kotlin_it_unibo_tuprolog_core.$_$.y1;
+  var Fact = kotlin_it_unibo_tuprolog_core.$_$.s1;
+  var Directive = kotlin_it_unibo_tuprolog_core.$_$.r1;
+  var interfaceMeta = kotlin_kotlin.$_$.u6;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_core.$_$.v;
+  var THROW_CCE = kotlin_kotlin.$_$.sb;
+  var contains = kotlin_kotlin.$_$.l3;
+  var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_core.$_$.r;
+  var map = kotlin_kotlin.$_$.c9;
+  var Operator = kotlin_it_unibo_tuprolog_core.$_$.n1;
+  var List = kotlin_it_unibo_tuprolog_core.$_$.v1;
+  var toString = kotlin_kotlin.$_$.n7;
+  var coerceAtLeast = kotlin_kotlin.$_$.y7;
+  var isRecognitionException = kotlin_it_unibo_tuprolog_parser_js.$_$.b;
+  var isParseCancellationException = kotlin_it_unibo_tuprolog_parser_js.$_$.a;
+  var generateSequence = kotlin_kotlin.$_$.w8;
+  var takeWhile = kotlin_kotlin.$_$.l9;
+  var to = kotlin_kotlin.$_$.ec;
+  var Companion_getInstance_3 = kotlin_kt_math.$_$.f;
+  var charSequenceGet = kotlin_kotlin.$_$.k6;
+  var Char__toInt_impl_vasixd = kotlin_kotlin.$_$.g2;
+  var contains$default = kotlin_kotlin.$_$.j;
+  var plus = kotlin_kotlin.$_$.zb;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.r1;
+  var listOf = kotlin_kotlin.$_$.h4;
+  var asList = kotlin_kotlin.$_$.c3;
+  var plus_0 = kotlin_kotlin.$_$.a5;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.j3;
+  var toList = kotlin_kotlin.$_$.o5;
+  var flatMap = kotlin_kotlin.$_$.u8;
+  var asSequence = kotlin_kotlin.$_$.g3;
+  var toList_0 = kotlin_kotlin.$_$.p9;
+  var sequenceOf = kotlin_kotlin.$_$.i9;
+  var asSequence_0 = kotlin_kotlin.$_$.h3;
+  var plus_1 = kotlin_kotlin.$_$.g9;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.p1;
+  var Term = kotlin_it_unibo_tuprolog_core.$_$.y2;
+  var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.x;
+  var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_core.$_$.a1;
+  var NumberFormatException = kotlin_kotlin.$_$.pb;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(ParseException, 'ParseException', classMeta, TuPrologException, undefined, undefined, undefined, []);
+  setMetadataFor(InvalidTermTypeException, 'InvalidTermTypeException', classMeta, ParseException, undefined, undefined, undefined, []);
+  setMetadataFor(Companion, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  function parseTerm(input) {
+    return this.parseTermWithOperators(input, this.c3j());
+  }
+  function parseStructWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Struct) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Struct);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseStruct(input) {
+    return this.parseStructWithOperators(input, this.c3j());
+  }
+  function parseConstantWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Constant) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Constant);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseConstant(input) {
+    return this.parseConstantWithOperators(input, this.c3j());
+  }
+  function parseVarWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Var) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Var);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseVar(input) {
+    return this.parseVarWithOperators(input, this.c3j());
+  }
+  function parseAtomWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Atom) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Atom);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseAtom(input) {
+    return this.parseAtomWithOperators(input, this.c3j());
+  }
+  function parseNumericWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Numeric) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Numeric);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseNumeric(input) {
+    return this.parseNumericWithOperators(input, this.c3j());
+  }
+  function parseIntegerWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Integer) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Integer);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseInteger(input) {
+    return this.parseIntegerWithOperators(input, this.c3j());
+  }
+  function parseRealWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Real) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Real);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseReal(input) {
+    return this.parseRealWithOperators(input, this.c3j());
+  }
+  function parseClauseWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Clause) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Clause);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseClause(input) {
+    return this.parseClauseWithOperators(input, this.c3j());
+  }
+  function parseRuleWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Rule) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Rule);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseRule(input) {
+    return this.parseRuleWithOperators(input, this.c3j());
+  }
+  function parseFactWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Fact) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Fact);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseFact(input) {
+    return this.parseFactWithOperators(input, this.c3j());
+  }
+  function parseDirectiveWithOperators(input, operators) {
+    var tmp$ret$2;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs' call
+    var tmp1_parseAs = Companion_getInstance_6();
+    var tmp$ret$1;
+    // Inline function 'kotlin.let' call
+    var tmp0_let = this.parseTermWithOperators(input, operators);
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp$ret$0;
+    // Inline function 'it.unibo.tuprolog.core.parsing.Companion.parseAs.<anonymous>' call
+    var tmp0_elvis_lhs = isInterface(tmp0_let, Directive) ? tmp0_let : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = getKClass(Directive);
+      throw InvalidTermTypeException_init_$Create$(input, tmp0_let, tmp_0, null, 0, 0, null, null, 248, null);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    tmp$ret$0 = tmp;
+    tmp$ret$1 = tmp$ret$0;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function parseDirective(input) {
+    return this.parseDirectiveWithOperators(input, this.c3j());
+  }
+  setMetadataFor(TermParser, 'TermParser', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_0, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(DynamicOpListener, 'DynamicOpListener', classMeta, PrologParserListener, undefined, undefined, undefined, []);
+  setMetadataFor(PrologParserFactory$newErrorListener$1, undefined, classMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(PrologParserFactory, 'PrologParserFactory', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(PrologVisitor, 'PrologVisitor', classMeta, PrologParserVisitor, undefined, undefined, undefined, []);
+  setMetadataFor(TermParserImpl, 'TermParserImpl', classMeta, undefined, [TermParser], undefined, undefined, []);
+  //endregion
+  function InvalidTermTypeException_init_$Init$(input, term, type, offendingSymbol, line, column, message, throwable, $mask0, $marker, $this) {
+    if (!(($mask0 & 8) === 0)) {
+      var tmp0_elvis_lhs = (!(input == null) ? typeof input === 'string' : false) ? input : null;
+      offendingSymbol = tmp0_elvis_lhs == null ? term.toString() : tmp0_elvis_lhs;
+    }
+    if (!(($mask0 & 16) === 0))
+      line = 1;
+    if (!(($mask0 & 32) === 0))
+      column = 1;
+    if (!(($mask0 & 64) === 0))
+      message = 'Expected ' + type.kd() + ', got: ' + offendingSymbol;
+    if (!(($mask0 & 128) === 0))
+      throwable = null;
+    InvalidTermTypeException.call($this, input, term, type, offendingSymbol, line, column, message, throwable);
+    return $this;
+  }
+  function InvalidTermTypeException_init_$Create$(input, term, type, offendingSymbol, line, column, message, throwable, $mask0, $marker) {
+    var tmp = InvalidTermTypeException_init_$Init$(input, term, type, offendingSymbol, line, column, message, throwable, $mask0, $marker, Object.create(InvalidTermTypeException.prototype));
+    captureStack(tmp, InvalidTermTypeException_init_$Create$);
+    return tmp;
+  }
+  function InvalidTermTypeException(input, term, type, offendingSymbol, line, column, message, throwable) {
+    ParseException.call(this, input, offendingSymbol, line, column, message, throwable);
+    this.k3i_1 = term;
+    this.l3i_1 = type;
+    captureStack(this, InvalidTermTypeException);
+  }
+  function ParseException(input, offendingSymbol, line, column, message, throwable) {
+    TuPrologException_init_$Init$(message, throwable, this);
+    this.input = input;
+    this.offendingSymbol = offendingSymbol;
+    this.line = line;
+    this.column = column;
+    this.clauseIndex = -1;
+    captureStack(this, ParseException);
+  }
+  ParseException.prototype.m3i = function (_set____db54di) {
+    this.input = _set____db54di;
+  };
+  ParseException.prototype.n3i = function () {
+    return this.input;
+  };
+  ParseException.prototype.o3i = function (_set____db54di) {
+    this.offendingSymbol = _set____db54di;
+  };
+  ParseException.prototype.p3i = function () {
+    return this.offendingSymbol;
+  };
+  ParseException.prototype.q3i = function (_set____db54di) {
+    this.line = _set____db54di;
+  };
+  ParseException.prototype.r3i = function () {
+    return this.line;
+  };
+  ParseException.prototype.s3i = function (_set____db54di) {
+    this.column = _set____db54di;
+  };
+  ParseException.prototype.t3i = function () {
+    return this.column;
+  };
+  ParseException.prototype.u3i = function (_set____db54di) {
+    this.clauseIndex = _set____db54di;
+  };
+  ParseException.prototype.v3i = function () {
+    return this.clauseIndex;
+  };
+  ParseException.prototype.toString = function () {
+    var tmp = ensureNotNull(this.message);
+    return "ParseException{message='" + replace$default(tmp, '\\n', '\\\\n', false, 4, null) + new Char(_Char___init__impl__6a9atx(39)) + ', line=' + this.line + ', column=' + this.column + ", offendingSymbol='" + this.offendingSymbol + new Char(_Char___init__impl__6a9atx(39)) + new Char(_Char___init__impl__6a9atx(125));
+  };
+  function Companion() {
+    Companion_instance = this;
+  }
+  Companion.prototype.withNoOperator = function (scope) {
+    return this.w3i(scope === void 1 ? Companion_getInstance().empty() : scope);
+  };
+  Companion.prototype.w3i = function (scope) {
+    return this.x3i(Companion_getInstance_0().EMPTY, scope);
+  };
+  Companion.prototype.withStandardOperators = function (scope) {
+    return this.y3i(scope === void 1 ? Companion_getInstance().empty() : scope);
+  };
+  Companion.prototype.y3i = function (scope) {
+    return this.x3i(Companion_getInstance_0().STANDARD, scope);
+  };
+  Companion.prototype.withDefaultOperators = function (scope) {
+    return this.z3i(scope === void 1 ? Companion_getInstance().empty() : scope);
+  };
+  Companion.prototype.z3i = function (scope) {
+    return this.x3i(Companion_getInstance_0().DEFAULT, scope);
+  };
+  Companion.prototype.a3j = function (scope, $mask0, $handler) {
+    if (!(($mask0 & 1) === 0))
+      scope = Companion_getInstance().empty();
+    return this.z3i(scope);
+  };
+  Companion.prototype.withOperatorSet = function (operators, scope) {
+    return this.x3i(operators, scope === void 1 ? Companion_getInstance().empty() : scope);
+  };
+  Companion.prototype.x3i = function (operators, scope) {
+    return termParserWithOperators(operators, scope);
+  };
+  Companion.prototype.withOperators = function (operators, scope) {
+    return this.b3j(operators, scope === void 1 ? Companion_getInstance().empty() : scope);
+  };
+  Companion.prototype.b3j = function (operators, scope) {
+    return this.x3i(OperatorSet_init_$Create$(operators.slice()), scope);
+  };
+  var Companion_instance;
+  function Companion_getInstance_6() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function TermParser() {
+  }
+  function toClause(_this__u8e3s4, source, line, column) {
+    var tmp0_subject = _this__u8e3s4;
+    var tmp;
+    if (isInterface(tmp0_subject, Clause)) {
+      tmp = _this__u8e3s4;
+    } else {
+      if (isInterface(tmp0_subject, Struct)) {
+        tmp = Companion_getInstance_1().of(_this__u8e3s4);
+      } else {
+        var tmp_0 = getKClass(Clause);
+        throw InvalidTermTypeException_init_$Create$(source, _this__u8e3s4, tmp_0, null, line, column, null, null, 200, null);
+      }
+    }
+    return tmp;
+  }
+  function toClause$default(_this__u8e3s4, source, line, column, $mask0, $handler) {
+    if (!(($mask0 & 1) === 0))
+      source = null;
+    if (!(($mask0 & 2) === 0))
+      line = 0;
+    if (!(($mask0 & 4) === 0))
+      column = 0;
+    return toClause(_this__u8e3s4, source, line, column);
+  }
+  function parseStructWithOperators_0(_this__u8e3s4, input, operators) {
+    return get_defaultParser().parseStructWithOperators(input, operators);
+  }
+  function parseStruct_0(_this__u8e3s4, input) {
+    return get_defaultParser().parseStruct(input);
+  }
+  function get_defaultParser() {
+    var tmp = Companion_getInstance_6();
+    return tmp.a3j(null, 1, null);
+  }
+  function toAssociativity(_this__u8e3s4) {
+    return _this__u8e3s4.toString();
+  }
+  function DynamicOpListener$Companion$of$lambda($this$$receiver, it) {
+    return Unit_getInstance();
+  }
+  function onOperatorDefined($this, operator) {
+    $this.d3j_1.addOperator(operator.n1i_1, toAssociativity(operator.o1i_1), operator.p1i_1);
+    $this.e3j_1($this.d3j_1, operator);
+  }
+  function Companion_0() {
+    Companion_instance_0 = this;
+  }
+  Companion_0.prototype.f3j = function (parser) {
+    return new DynamicOpListener(parser, DynamicOpListener$Companion$of$lambda);
+  };
+  var Companion_instance_0;
+  function Companion_getInstance_7() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function DynamicOpListener$exitClause$lambda(it) {
+    return isInterface(it, Atom) ? it : THROW_CCE();
+  }
+  function DynamicOpListener(parser, operatorDefinedCallback) {
+    Companion_getInstance_7();
+    PrologParserListener.call(this);
+    this.d3j_1 = parser;
+    this.e3j_1 = operatorDefinedCallback;
+  }
+  DynamicOpListener.prototype.g3j = function (ctx) {
+    var expr = ctx.expression();
+    if (ctx.exception != null) {
+      return Unit_getInstance();
+    }
+    var tmp;
+    var tmp_0;
+    if (!(expr._op == null)) {
+      var tmp0_safe_receiver = expr._op;
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.symbol;
+      tmp_0 = ':-' === (tmp1_safe_receiver == null ? null : tmp1_safe_receiver.text);
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = contains(Associativity.PREFIX, expr.associativity);
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      var tmp_1 = ctx.accept(PrologVisitor_init_$Create$(null, 1, null));
+      var directive = isInterface(tmp_1, Directive) ? tmp_1 : THROW_CCE();
+      var op = directive.my();
+      var tmp_2;
+      var tmp_3;
+      var tmp_4;
+      var tmp_5;
+      var tmp_6;
+      if (isInterface(op, Struct)) {
+        tmp_6 = op.zv() === 3;
+      } else {
+        tmp_6 = false;
+      }
+      if (tmp_6) {
+        tmp_5 = op.fw() === 'op';
+      } else {
+        tmp_5 = false;
+      }
+      if (tmp_5) {
+        var tmp_7 = op.get(0);
+        tmp_4 = isInterface(tmp_7, Numeric);
+      } else {
+        tmp_4 = false;
+      }
+      if (tmp_4) {
+        var tmp_8 = op.get(1);
+        tmp_3 = isInterface(tmp_8, Atom);
+      } else {
+        tmp_3 = false;
+      }
+      if (tmp_3) {
+        tmp_2 = op.jx();
+      } else {
+        tmp_2 = false;
+      }
+      if (tmp_2) {
+        var tmp$ret$1;
+        // Inline function 'kotlin.math.min' call
+        var tmp$ret$0;
+        // Inline function 'kotlin.math.max' call
+        var tmp_9 = op.get(0);
+        var tmp0_max = (isInterface(tmp_9, Numeric) ? tmp_9 : THROW_CCE()).p10().toInt();
+        tmp$ret$0 = Math.max(0, tmp0_max);
+        var tmp1_min = tmp$ret$0;
+        tmp$ret$1 = Math.min(1200, tmp1_min);
+        var priority = tmp$ret$1;
+        var specifier = Companion_getInstance_2().fromTerm(op.get(1));
+        var operator = op.get(2);
+        if (isInterface(operator, Atom)) {
+          onOperatorDefined(this, new Operator(operator.b1(), specifier, priority));
+        } else {
+          if (isInterface(operator, List)) {
+            var tmp$ret$3;
+            $l$block: {
+              // Inline function 'kotlin.sequences.all' call
+              var tmp2_all = operator.ju();
+              var tmp0_iterator = tmp2_all.j();
+              while (tmp0_iterator.m()) {
+                var element = tmp0_iterator.p();
+                var tmp$ret$2;
+                // Inline function 'it.unibo.tuprolog.core.parsing.DynamicOpListener.exitClause.<anonymous>' call
+                tmp$ret$2 = isInterface(element, Atom);
+                if (!tmp$ret$2) {
+                  tmp$ret$3 = false;
+                  break $l$block;
+                }
+              }
+              tmp$ret$3 = true;
+            }
+            if (tmp$ret$3) {
+              var tmp_10 = operator.ju();
+              var tmp2_iterator = map(tmp_10, DynamicOpListener$exitClause$lambda).j();
+              while (tmp2_iterator.m()) {
+                var it = tmp2_iterator.p();
+                onOperatorDefined(this, new Operator(it.b1(), specifier, priority));
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  DynamicOpListener.prototype.exitClause = function (ctx) {
+    return this.g3j(ctx);
+  };
+  function parseException(token, message) {
+    return new ParseException(null, token.text, token.line, token.column, message, null);
+  }
+  function symbolToString($this, obj) {
+    var tmp;
+    if (obj instanceof Token) {
+      tmp = obj.text;
+    } else {
+      tmp = toString(obj);
+    }
+    return tmp;
+  }
+  function newErrorListener($this, whileParsing) {
+    return new PrologParserFactory$newErrorListener$1(whileParsing);
+  }
+  function parseExpression($this, parserAndErrorStrategy, source) {
+    var mark = -1;
+    var index = -1;
+    var parser = parserAndErrorStrategy.g4_1;
+    var tmp;
+    try {
+      mark = parser.getTokenStream().mark();
+      index = coerceAtLeast(parser.getTokenStream().index, 0);
+      tmp = parser.singletonExpression();
+    } catch ($p) {
+      var tmp_0;
+      {
+        var tmp_1;
+        if (isParseCancellationException($p) ? parser._interp.predictionMode === PredictionMode.SLL : false) {
+          parser.getTokenStream().seek(index);
+          parser._interp.predictionMode = PredictionMode.LL;
+          parser._errHandler = parserAndErrorStrategy.h4_1;
+          parser.addErrorListener(newErrorListener($this, source));
+          tmp_1 = parseExpression($this, parserAndErrorStrategy, source);
+        } else if ($p.clause !== null ? isRecognitionException($p.cause) : false) {
+          var tmp_2 = $p.cause;
+          throw tmp_2 instanceof RecognitionException ? tmp_2 : THROW_CCE();
+        } else {
+          throw $p instanceof Error ? $p : THROW_CCE();
+        }
+        tmp_0 = tmp_1;
+      }
+      tmp = tmp_0;
+    }
+    finally {
+      parser.getTokenStream().release(mark);
+    }
+    return tmp;
+  }
+  function parseClause_0($this, parserAndErrorStrategy, source) {
+    var mark = -1;
+    var index = -1;
+    var parser = parserAndErrorStrategy.g4_1;
+    var tmp;
+    try {
+      mark = parser.getTokenStream().mark();
+      index = coerceAtLeast(parser.getTokenStream().index, 0);
+      tmp = parser.optClause();
+    } catch ($p) {
+      var tmp_0;
+      {
+        var tmp_1;
+        if (isParseCancellationException($p) ? parser._interp.predictionMode === PredictionMode.SLL : false) {
+          parser.getTokenStream().seek(index);
+          parser._interp.predictionMode = PredictionMode.LL;
+          parser._errHandler = parserAndErrorStrategy.h4_1;
+          parser.addErrorListener(newErrorListener($this, source));
+          tmp_1 = parseClause_0($this, parserAndErrorStrategy, source);
+        } else if ($p.clause !== null ? isRecognitionException($p.cause) : false) {
+          var tmp_2 = $p.cause;
+          throw tmp_2 instanceof RecognitionException ? tmp_2 : THROW_CCE();
+        } else {
+          throw $p instanceof Error ? $p : THROW_CCE();
+        }
+        tmp_0 = tmp_1;
+      }
+      tmp = tmp_0;
+    }
+    finally {
+      parser.getTokenStream().release(mark);
+    }
+    return tmp;
+  }
+  function parseClauses($this, parser, source) {
+    var tmp = generateSequence(0, PrologParserFactory$parseClauses$lambda);
+    var tmp_0 = map(tmp, PrologParserFactory$parseClauses$lambda_0(parser, source));
+    var tmp_1 = takeWhile(tmp_0, PrologParserFactory$parseClauses$lambda_1);
+    return map(tmp_1, PrologParserFactory$parseClauses$lambda_2);
+  }
+  function PrologParserFactory$newErrorListener$1($whileParsing) {
+    this.h3j_1 = $whileParsing;
+  }
+  PrologParserFactory$newErrorListener$1.prototype.syntaxError = function (recognizer, offendingSymbol, line, column, msg, e) {
+    if (recognizer instanceof PrologParser) {
+      recognizer.removeParseListeners();
+    }
+    throw new ParseException(this.h3j_1, symbolToString(this, offendingSymbol), line, column + 1 | 0, msg, e);
+  };
+  function PrologParserFactory$parseClauses$lambda(it) {
+    return it + 1 | 0;
+  }
+  function PrologParserFactory$parseClauses$lambda_0($parser, $source) {
+    return function (it) {
+      var tmp;
+      try {
+        tmp = parseClause_0(PrologParserFactory_getInstance(), $parser, $source);
+      } catch ($p) {
+        var tmp_0;
+        if ($p instanceof ParseException) {
+          $p.clauseIndex = it;
+          throw $p;
+        } else {
+          throw $p;
+        }
+        tmp = tmp_0;
+      }
+      return tmp;
+    };
+  }
+  function PrologParserFactory$parseClauses$lambda_1(it) {
+    return !it.isOver;
+  }
+  function PrologParserFactory$parseClauses$lambda_2(it) {
+    return it.clause();
+  }
+  function PrologParserFactory() {
+    PrologParserFactory_instance = this;
+  }
+  PrologParserFactory.prototype.i3j = function (string, withOperators) {
+    var parser = this.j3j(string, withOperators);
+    return parseExpression(this, parser, string);
+  };
+  PrologParserFactory.prototype.k3j = function (source, withOperators) {
+    var parser = this.j3j(source, withOperators);
+    return parseClauses(this, parser, source);
+  };
+  PrologParserFactory.prototype.j3j = function (source, operators) {
+    var stream = new InputStream(source);
+    var lexer = new PrologLexer(stream);
+    lexer.removeErrorListeners();
+    var tokenStream = new CommonTokenStream(lexer);
+    var parser = new PrologParser(tokenStream);
+    parser.removeErrorListeners();
+    var originalErrorStrategy = parser._errHandler;
+    parser._errHandler = new BailErrorStrategy();
+    parser._interp.predictionMode = PredictionMode.SLL;
+    return to(this.l3j(parser, operators), originalErrorStrategy);
+  };
+  PrologParserFactory.prototype.l3j = function (prologParser, operators) {
+    // Inline function 'kotlin.collections.forEach' call
+    var tmp0_iterator = operators.j();
+    while (tmp0_iterator.m()) {
+      var element = tmp0_iterator.p();
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologParserFactory.addOperators.<anonymous>' call
+      prologParser.addOperator(element.n1i_1, toAssociativity(element.o1i_1), element.p1i_1);
+    }
+    prologParser.addParseListener(Companion_getInstance_7().f3j(prologParser));
+    return prologParser;
+  };
+  var PrologParserFactory_instance;
+  function PrologParserFactory_getInstance() {
+    if (PrologParserFactory_instance == null)
+      new PrologParserFactory();
+    return PrologParserFactory_instance;
+  }
+  function PrologVisitor_init_$Init$(scope, $mask0, $marker, $this) {
+    if (!(($mask0 & 1) === 0))
+      scope = Companion_getInstance().empty();
+    PrologVisitor.call($this, scope);
+    return $this;
+  }
+  function PrologVisitor_init_$Create$(scope, $mask0, $marker) {
+    return PrologVisitor_init_$Init$(scope, $mask0, $marker, Object.create(PrologVisitor.prototype));
+  }
+  function parseInteger_0($this, ctx) {
+    var str = ctx.value.text;
+    var base;
+    var clean;
+    if (ctx.isBin) {
+      base = 2;
+      var tmp$ret$1;
+      // Inline function 'kotlin.text.substring' call
+      var tmp$ret$0;
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp$ret$0 = str;
+      tmp$ret$1 = tmp$ret$0.substring(2);
+      clean = tmp$ret$1;
+    } else if (ctx.isOct) {
+      base = 8;
+      var tmp$ret$3;
+      // Inline function 'kotlin.text.substring' call
+      var tmp$ret$2;
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp$ret$2 = str;
+      tmp$ret$3 = tmp$ret$2.substring(2);
+      clean = tmp$ret$3;
+    } else if (ctx.isHex) {
+      base = 16;
+      var tmp$ret$5;
+      // Inline function 'kotlin.text.substring' call
+      var tmp$ret$4;
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp$ret$4 = str;
+      tmp$ret$5 = tmp$ret$4.substring(2);
+      clean = tmp$ret$5;
+    } else if (ctx.isChar) {
+      var tmp$ret$7;
+      // Inline function 'kotlin.text.substring' call
+      var tmp$ret$6;
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp$ret$6 = str;
+      tmp$ret$7 = tmp$ret$6.substring(2);
+      clean = tmp$ret$7;
+      if (!(clean.length === 1)) {
+        throw parseException(ctx.value, 'Invalid character literal: ' + ctx.value.text);
+      }
+      var tmp$ret$10;
+      // Inline function 'kotlin.with' call
+      var tmp = Companion_getInstance_3();
+      var tmp$ret$8;
+      // Inline function 'kotlin.code' call
+      var tmp0__get_code__88qj9g = charSequenceGet(clean, 0);
+      tmp$ret$8 = Char__toInt_impl_vasixd(tmp0__get_code__88qj9g);
+      var tmp1_with = tmp.of(tmp$ret$8);
+      // Inline function 'kotlin.contracts.contract' call
+      var tmp$ret$9;
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.parseInteger.<anonymous>' call
+      var tmp_0;
+      var tmp0_safe_receiver = ctx.sign;
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.text;
+      var tmp_1;
+      if (tmp1_safe_receiver == null) {
+        tmp_1 = null;
+      } else {
+        tmp_1 = contains$default(tmp1_safe_receiver, '-', false, 2, null);
+      }
+      var tmp2_elvis_lhs = tmp_1;
+      if (tmp2_elvis_lhs == null ? false : tmp2_elvis_lhs) {
+        tmp_0 = tmp1_with.unaryMinus();
+      } else {
+        tmp_0 = tmp1_with;
+      }
+      tmp$ret$9 = tmp_0;
+      tmp$ret$10 = tmp$ret$9;
+      return tmp$ret$10;
+    } else {
+      base = 10;
+      clean = str;
+    }
+    if (!(ctx.sign == null)) {
+      var tmp0_safe_receiver_0 = ctx.sign;
+      clean = plus(tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.text, clean);
+    }
+    return Companion_getInstance_3().parseWithRadix(clean, base);
+  }
+  function visitPostfixExpression($this, ctx) {
+    var tmp0_safe_receiver = ctx.left;
+    var tmp = ensureNotNull(tmp0_safe_receiver == null ? null : tmp0_safe_receiver.accept($this));
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = ctx.operators;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(tmp0_map.length);
+    var indexedObject = tmp0_map;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.visitPostfixExpression.<anonymous>' call
+      tmp$ret$0 = item.symbol.text;
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return postfix($this, tmp, tmp$ret$2);
+  }
+  function postfix($this, term, ops) {
+    var operator = ops.j();
+    var result = $this.m3j_1.structOf(operator.p(), [term]);
+    while (operator.m()) {
+      result = $this.m3j_1.structOf(operator.p(), [result]);
+    }
+    return result;
+  }
+  function visitPrefixExpression($this, ctx) {
+    var tmp = ctx.right[0].accept($this);
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = ctx.operators;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(tmp0_map.length);
+    var indexedObject = tmp0_map;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.visitPrefixExpression.<anonymous>' call
+      tmp$ret$0 = item.symbol.text;
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return prefix($this, tmp, tmp$ret$2);
+  }
+  function prefix($this, term, ops) {
+    var i = ops.o() - 1 | 0;
+    var tmp0 = i;
+    i = tmp0 - 1 | 0;
+    var result = $this.m3j_1.structOf(ops.n(tmp0), [term]);
+    while (i >= 0) {
+      result = $this.m3j_1.structOf(ops.n(i), [result]);
+      var tmp1 = i;
+      i = tmp1 - 1 | 0;
+    }
+    return result;
+  }
+  function visitInfixExpression($this, ctx) {
+    var tmp0_subject = ctx.associativity;
+    var tmp;
+    if (tmp0_subject === Associativity.XFY) {
+      tmp = visitInfixRightAssociativeExpression($this, ctx);
+    } else if (tmp0_subject === Associativity.YFX) {
+      tmp = visitInfixLeftAssociativeExpression($this, ctx);
+    } else if (tmp0_subject === Associativity.XFX) {
+      tmp = visitInfixNonAssociativeExpression($this, ctx);
+    } else {
+      throw IllegalStateException_init_$Create$();
+    }
+    return tmp;
+  }
+  function visitInfixNonAssociativeExpression($this, ctx) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = plus_0(listOf(ensureNotNull(ctx.left)), asList(ctx.right));
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+    var tmp0_iterator = tmp0_map.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.visitInfixNonAssociativeExpression.<anonymous>' call
+      tmp$ret$0 = item.accept($this);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    var operands = tmp$ret$2;
+    var tmp$ret$5;
+    // Inline function 'kotlin.collections.map' call
+    var tmp1_map = ctx.operators;
+    var tmp$ret$4;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo_0 = ArrayList_init_$Create$(tmp1_map.length);
+    var indexedObject = tmp1_map;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item_0 = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$3;
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.visitInfixNonAssociativeExpression.<anonymous>' call
+      tmp$ret$3 = item_0.symbol.text;
+      tmp0_mapTo_0.g(tmp$ret$3);
+    }
+    tmp$ret$4 = tmp0_mapTo_0;
+    tmp$ret$5 = tmp$ret$4;
+    var operators = tmp$ret$5;
+    return infixNonAssociative($this, operands, operators);
+  }
+  function infixNonAssociative($this, terms, ops) {
+    return $this.m3j_1.structOf(ops.n(0), [terms.n(0), terms.n(1)]);
+  }
+  function handleOuters($this, expression, outers) {
+    var result = expression;
+    var tmp0_iterator = outers.j();
+    while (tmp0_iterator.m()) {
+      var o = tmp0_iterator.p();
+      var tmp = listOf(result);
+      var tmp$ret$2;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = o.right;
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(tmp0_map.length);
+      var indexedObject = tmp0_map;
+      var inductionVariable = 0;
+      var last = indexedObject.length;
+      while (inductionVariable < last) {
+        var item = indexedObject[inductionVariable];
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp$ret$0;
+        // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.handleOuters.<anonymous>' call
+        tmp$ret$0 = item.accept($this);
+        tmp0_mapTo.g(tmp$ret$0);
+      }
+      tmp$ret$1 = tmp0_mapTo;
+      tmp$ret$2 = tmp$ret$1;
+      var operands = plus_0(tmp, tmp$ret$2);
+      var tmp$ret$5;
+      // Inline function 'kotlin.collections.map' call
+      var tmp1_map = o.operators;
+      var tmp$ret$4;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo_0 = ArrayList_init_$Create$(tmp1_map.length);
+      var indexedObject_0 = tmp1_map;
+      var inductionVariable_0 = 0;
+      var last_0 = indexedObject_0.length;
+      while (inductionVariable_0 < last_0) {
+        var item_0 = indexedObject_0[inductionVariable_0];
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        var tmp$ret$3;
+        // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.handleOuters.<anonymous>' call
+        tmp$ret$3 = item_0.symbol.text;
+        tmp0_mapTo_0.g(tmp$ret$3);
+      }
+      tmp$ret$4 = tmp0_mapTo_0;
+      tmp$ret$5 = tmp$ret$4;
+      var operators = tmp$ret$5;
+      var tmp1_subject = o.associativity;
+      var tmp_0;
+      if (tmp1_subject === Associativity.XFY) {
+        tmp_0 = infixRight($this, operands, operators);
+      } else if (tmp1_subject === Associativity.XF ? true : tmp1_subject === Associativity.YF) {
+        tmp_0 = postfix($this, result, operators);
+      } else if (tmp1_subject === Associativity.XFX) {
+        tmp_0 = infixNonAssociative($this, operands, operators);
+      } else if (tmp1_subject === Associativity.YFX) {
+        tmp_0 = infixLeft($this, operands, operators);
+      } else if (tmp1_subject === Associativity.FX ? true : tmp1_subject === Associativity.FY) {
+        tmp_0 = prefix($this, result, operators);
+      } else {
+        throw IllegalStateException_init_$Create$();
+      }
+      result = tmp_0;
+    }
+    return result;
+  }
+  function infixRight($this, terms, ops) {
+    var i = terms.o() - 1 | 0;
+    var j = ops.o() - 1 | 0;
+    var tmp0 = j;
+    j = tmp0 - 1 | 0;
+    var result = $this.m3j_1.structOf(ops.n(tmp0), [terms.n(i - 1 | 0), terms.n(i)]);
+    i = i - 2 | 0;
+    while (i >= 0) {
+      var tmp1 = j;
+      j = tmp1 - 1 | 0;
+      result = $this.m3j_1.structOf(ops.n(tmp1), [terms.n(i), result]);
+      var tmp2 = i;
+      i = tmp2 - 1 | 0;
+    }
+    return result;
+  }
+  function infixLeft($this, terms, ops) {
+    var i = 0;
+    var j = 0;
+    var tmp0 = j;
+    j = tmp0 + 1 | 0;
+    var tmp = ops.n(tmp0);
+    var tmp1 = i;
+    i = tmp1 + 1 | 0;
+    var tmp_0 = terms.n(tmp1);
+    var tmp2 = i;
+    i = tmp2 + 1 | 0;
+    var result = $this.m3j_1.structOf(tmp, [tmp_0, terms.n(tmp2)]);
+    while (i < terms.o()) {
+      var tmp3 = j;
+      j = tmp3 + 1 | 0;
+      result = $this.m3j_1.structOf(ops.n(tmp3), [result, terms.n(i)]);
+      var tmp4 = i;
+      i = tmp4 + 1 | 0;
+    }
+    return result;
+  }
+  function listOfOperands($this, ctx) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = plus_0(listOf(ctx.left), toList(ctx.right));
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0_map, 10));
+    var tmp0_iterator = tmp0_map.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.listOfOperands.<anonymous>' call
+      tmp$ret$0 = ensureNotNull(item).accept($this);
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function listOfOperators($this, ctx) {
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = ctx.operators;
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(tmp0_map.length);
+    var indexedObject = tmp0_map;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.core.parsing.PrologVisitor.listOfOperators.<anonymous>' call
+      tmp$ret$0 = item.symbol.text;
+      tmp0_mapTo.g(tmp$ret$0);
+    }
+    tmp$ret$1 = tmp0_mapTo;
+    tmp$ret$2 = tmp$ret$1;
+    return tmp$ret$2;
+  }
+  function visitInfixRightAssociativeExpression($this, ctx) {
+    return infixRight($this, listOfOperands($this, ctx), listOfOperators($this, ctx));
+  }
+  function visitInfixLeftAssociativeExpression($this, ctx) {
+    return infixLeft($this, listOfOperands($this, ctx), listOfOperators($this, ctx));
+  }
+  function flatten($this, outers) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.sequences.asSequence' call
+    tmp$ret$0 = outers;
+    var tmp = tmp$ret$0;
+    return flatMap(tmp, PrologVisitor$flatten$lambda($this));
+  }
+  function flatten_0($this, outers) {
+    return toList_0(flatten($this, asSequence(outers)));
+  }
+  function PrologVisitor$visitExpression$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.n3j(p0);
+    };
+    l.callableName = 'visitExpression';
+    return l;
+  }
+  function PrologVisitor$flatten$lambda(this$0) {
+    return function (it) {
+      return plus_1(sequenceOf([it]), flatten(this$0, asSequence_0(it.outers)));
+    };
+  }
+  function PrologVisitor(scope) {
+    PrologParserVisitor.call(this);
+    this.m3j_1 = scope;
+  }
+  PrologVisitor.prototype.o3j = function (ctx) {
+    return this.p3j(ctx.term());
+  };
+  PrologVisitor.prototype.visitSingletonTerm = function (ctx) {
+    return this.o3j(ctx);
+  };
+  PrologVisitor.prototype.q3j = function (ctx) {
+    return this.n3j(ctx.expression());
+  };
+  PrologVisitor.prototype.visitSingletonExpression = function (ctx) {
+    return this.q3j(ctx);
+  };
+  PrologVisitor.prototype.r3j = function (ctx) {
+    return toClause(ctx.expression().accept(this), null, ensureNotNull(ctx.start).line, ensureNotNull(ctx.start).column);
+  };
+  PrologVisitor.prototype.visitClause = function (ctx) {
+    return this.r3j(ctx);
+  };
+  PrologVisitor.prototype.n3j = function (ctx) {
+    var tmp;
+    if (ctx.isTerm) {
+      tmp = this.p3j(ensureNotNull(ctx.left));
+    } else if (contains(Associativity.INFIX, ctx.associativity)) {
+      tmp = visitInfixExpression(this, ctx);
+    } else if (contains(Associativity.POSTFIX, ctx.associativity)) {
+      tmp = visitPostfixExpression(this, ctx);
+    } else if (contains(Associativity.PREFIX, ctx.associativity)) {
+      tmp = visitPrefixExpression(this, ctx);
+    } else {
+      throw IllegalArgumentException_init_$Create$('Associativity unknown: ' + ctx.associativity + ' INFIX=' + Associativity.INFIX + ' PREFIX=' + Associativity.PREFIX + ' POSTFIX=' + Associativity.POSTFIX);
+    }
+    return handleOuters(this, tmp, flatten_0(this, asList(ctx.outers)));
+  };
+  PrologVisitor.prototype.visitExpression = function (ctx) {
+    return this.n3j(ctx);
+  };
+  PrologVisitor.prototype.p3j = function (ctx) {
+    var tmp;
+    if (ctx.isExpr) {
+      tmp = this.n3j(ctx.expression());
+    } else {
+      var tmp_0 = ctx.children[0].accept(this);
+      tmp = (!(tmp_0 == null) ? isInterface(tmp_0, Term) : false) ? tmp_0 : THROW_CCE();
+    }
+    return tmp;
+  };
+  PrologVisitor.prototype.visitTerm = function (ctx) {
+    return this.p3j(ctx);
+  };
+  PrologVisitor.prototype.s3j = function (ctx) {
+    var value = parseInteger_0(this, ctx);
+    return Companion_getInstance_4().ofBigInteger(value);
+  };
+  PrologVisitor.prototype.visitInteger = function (ctx) {
+    return this.s3j(ctx);
+  };
+  PrologVisitor.prototype.t3j = function (ctx) {
+    var tmp = ctx.children[0].accept(this);
+    return (!(tmp == null) ? isInterface(tmp, Term) : false) ? tmp : THROW_CCE();
+  };
+  PrologVisitor.prototype.visitNumber = function (ctx) {
+    return this.t3j(ctx);
+  };
+  PrologVisitor.prototype.u3j = function (ctx) {
+    var raw = ctx.value.text;
+    if (!(ctx.sign == null)) {
+      var tmp0_safe_receiver = ctx.sign;
+      raw = plus(tmp0_safe_receiver == null ? null : tmp0_safe_receiver.text, raw);
+    }
+    var tmp;
+    try {
+      tmp = Companion_getInstance_5().parse(raw);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof NumberFormatException) {
+        throw parseException(ctx.value, 'Invalid real number format: ' + ctx.value.text);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  PrologVisitor.prototype.visitReal = function (ctx) {
+    return this.u3j(ctx);
+  };
+  PrologVisitor.prototype.v3j = function (ctx) {
+    var tmp;
+    if (ctx.isAnonymous) {
+      tmp = this.m3j_1.anonymous();
+    } else {
+      tmp = this.m3j_1.varOf(ctx.value.text);
+    }
+    return tmp;
+  };
+  PrologVisitor.prototype.visitVariable = function (ctx) {
+    return this.v3j(ctx);
+  };
+  PrologVisitor.prototype.w3j = function (ctx) {
+    if (ctx.isList) {
+      return this.m3j_1.listOf([]);
+    } else if (ctx.isBlock) {
+      return this.m3j_1.setOf([]);
+    }
+    var tmp;
+    if (ctx.arity === 0) {
+      tmp = this.m3j_1.atomOf(ctx.functor.text);
+    } else {
+      var tmp_0 = ctx.functor.text;
+      var tmp_1 = asSequence_0(ctx.args);
+      tmp = this.m3j_1.structOfSequence(tmp_0, map(tmp_1, PrologVisitor$visitExpression$ref(this)));
+    }
+    return tmp;
+  };
+  PrologVisitor.prototype.visitStructure = function (ctx) {
+    return this.w3j(ctx);
+  };
+  PrologVisitor.prototype.x3j = function (ctx) {
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = ctx.items;
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$(tmp0_map.length);
+    var indexedObject = tmp0_map;
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var item = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      tmp0_mapTo.g(this.n3j(item));
+    }
+    tmp$ret$0 = tmp0_mapTo;
+    tmp$ret$1 = tmp$ret$0;
+    var terms = tmp$ret$1;
+    var tmp;
+    if (ctx.hasTail) {
+      var tmp0_safe_receiver = ctx.tail;
+      tmp = this.m3j_1.y11(terms, tmp0_safe_receiver == null ? null : tmp0_safe_receiver.accept(this));
+    } else {
+      tmp = this.m3j_1.listOfIterable(terms);
+    }
+    return tmp;
+  };
+  PrologVisitor.prototype.visitList = function (ctx) {
+    return this.x3j(ctx);
+  };
+  PrologVisitor.prototype.y3j = function (ctx) {
+    var tmp;
+    if (ctx.length === 1) {
+      tmp = this.m3j_1.setOf([ctx.items[0].accept(this)]);
+    } else {
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.map' call
+      var tmp0_map = ctx.items;
+      var tmp$ret$0;
+      // Inline function 'kotlin.collections.mapTo' call
+      var tmp0_mapTo = ArrayList_init_$Create$(tmp0_map.length);
+      var indexedObject = tmp0_map;
+      var inductionVariable = 0;
+      var last = indexedObject.length;
+      while (inductionVariable < last) {
+        var item = indexedObject[inductionVariable];
+        inductionVariable = inductionVariable + 1 | 0;
+        tmp0_mapTo.g(this.n3j(item));
+      }
+      tmp$ret$0 = tmp0_mapTo;
+      tmp$ret$1 = tmp$ret$0;
+      tmp = this.m3j_1.setOfIterable(tmp$ret$1);
+    }
+    return tmp;
+  };
+  PrologVisitor.prototype.visitBlock = function (ctx) {
+    return this.y3j(ctx);
+  };
+  function termParserWithOperators(operators, scope) {
+    return new TermParserImpl(scope, operators);
+  }
+  function TermParserImpl(scope, defaultOperatorSet) {
+    this.z3j_1 = scope;
+    this.a3k_1 = defaultOperatorSet;
+  }
+  TermParserImpl.prototype.c3j = function () {
+    return this.a3k_1;
+  };
+  TermParserImpl.prototype.b3k = function (input, operators) {
+    return PrologParserFactory_getInstance().i3j(input, operators).accept(new PrologVisitor(this.z3j_1));
+  };
+  TermParserImpl.prototype.parseTermWithOperators = function (input, operators) {
+    return this.b3k(input, operators);
+  };
+  //region block: post-declaration
+  TermParserImpl.prototype.parseTerm = parseTerm;
+  TermParserImpl.prototype.parseStructWithOperators = parseStructWithOperators;
+  TermParserImpl.prototype.parseStruct = parseStruct;
+  TermParserImpl.prototype.parseConstantWithOperators = parseConstantWithOperators;
+  TermParserImpl.prototype.parseConstant = parseConstant;
+  TermParserImpl.prototype.parseVarWithOperators = parseVarWithOperators;
+  TermParserImpl.prototype.parseVar = parseVar;
+  TermParserImpl.prototype.parseAtomWithOperators = parseAtomWithOperators;
+  TermParserImpl.prototype.parseAtom = parseAtom;
+  TermParserImpl.prototype.parseNumericWithOperators = parseNumericWithOperators;
+  TermParserImpl.prototype.parseNumeric = parseNumeric;
+  TermParserImpl.prototype.parseIntegerWithOperators = parseIntegerWithOperators;
+  TermParserImpl.prototype.parseInteger = parseInteger;
+  TermParserImpl.prototype.parseRealWithOperators = parseRealWithOperators;
+  TermParserImpl.prototype.parseReal = parseReal;
+  TermParserImpl.prototype.parseClauseWithOperators = parseClauseWithOperators;
+  TermParserImpl.prototype.parseClause = parseClause;
+  TermParserImpl.prototype.parseRuleWithOperators = parseRuleWithOperators;
+  TermParserImpl.prototype.parseRule = parseRule;
+  TermParserImpl.prototype.parseFactWithOperators = parseFactWithOperators;
+  TermParserImpl.prototype.parseFact = parseFact;
+  TermParserImpl.prototype.parseDirectiveWithOperators = parseDirectiveWithOperators;
+  TermParserImpl.prototype.parseDirective = parseDirective;
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = toClause$default;
+  _.$_$.b = PrologVisitor_init_$Create$;
+  _.$_$.c = PrologParserFactory_getInstance;
+  _.$_$.d = ParseException;
+  _.$_$.e = parseStruct_0;
+  _.$_$.f = parseStructWithOperators_0;
+  //endregion
+  return _;
+}(module.exports, require('@tuprolog/parser-utils'), require('antlr4'), require('antlr4/src/antlr4/error'), require('antlr4/src/antlr4/atn'), require('./kotlin-kotlin-stdlib-js-ir.js'), require('./2p-core.js'), require('./2p-parser-js.js'), require('./kt-math.js')));
+
+//# sourceMappingURL=2p-parser-core.js.map