@tuprolog/arg2p-core 0.6.4 → 0.6.7

package/kotlin/arg2p-core.js

@@ -77,6 +77,8 @@
   var equals = Kotlin.equals;
   var DomainError = $module$_2p_solve.it.unibo.tuprolog.solve.exception.error.DomainError;
   var DomainError$Expected = $module$_2p_solve.it.unibo.tuprolog.solve.exception.error.DomainError.Expected;
+  var SolveOptions = $module$_2p_solve.it.unibo.tuprolog.solve.SolveOptions;
+  var Long$Companion$MAX_VALUE = Kotlin.Long.MAX_VALUE;
   var Unit = Kotlin.kotlin.Unit;
   var filter = Kotlin.kotlin.sequences.filter_euau3h$;
   var prolog = $module$_2p_dsl_core.it.unibo.tuprolog.dsl.prolog;
@@ -114,13 +116,14 @@
   var IllegalArgumentException_init = Kotlin.kotlin.IllegalArgumentException_init;
   var copyToArray = Kotlin.kotlin.collections.copyToArray;
   var hashCode = Kotlin.hashCode;
+  var Collection = Kotlin.kotlin.collections.Collection;
   var AliasedLibrary = $module$_2p_solve.it.unibo.tuprolog.solve.library.AliasedLibrary;
   var compareBy = Kotlin.kotlin.comparisons.compareBy_bvgy4j$;
   var sortedWith = Kotlin.kotlin.sequences.sortedWith_vjgqpk$;
   var mapIndexed = Kotlin.kotlin.sequences.mapIndexed_b7yuyq$;
+  var Pair = Kotlin.kotlin.Pair;
   var firstOrNull = Kotlin.kotlin.sequences.firstOrNull_veqyi0$;
   var NoSuchElementException_init = Kotlin.kotlin.NoSuchElementException;
-  var addAll = Kotlin.kotlin.collections.addAll_ipc267$;
   var firstOrNull_0 = Kotlin.kotlin.collections.firstOrNull_2p1efm$;
   var plus_0 = Kotlin.kotlin.collections.plus_qloxvw$;
   var Cons = $module$_2p_core.it.unibo.tuprolog.core.Cons;
@@ -926,36 +929,18 @@
   PrologWithArgumentationImpl.prototype.write1 = function (term) {
     return this.$delegate_38xz9p$_0.write1(term);
   };
-  PrologWithArgumentationImpl.prototype.neq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.neq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.nid2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.nid2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.power = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.power($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.eq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.eq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.arithNeq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.arithNeq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.id2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.id2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.arithEq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.arithEq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.pow = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.pow($receiver, right);
-  };
   PrologWithArgumentationImpl.prototype.anyAnd = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyAnd($receiver, other);
   };
   PrologWithArgumentationImpl.prototype.append = function ($receiver, item, items) {
     return this.$delegate_38xz9p$_0.append($receiver, item, items);
   };
+  PrologWithArgumentationImpl.prototype.arithEq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.arithEq2($receiver, right);
+  };
+  PrologWithArgumentationImpl.prototype.arithNeq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.arithNeq2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.concat = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.concat($receiver, other);
   };
@@ -971,6 +956,9 @@
   PrologWithArgumentationImpl.prototype.anyDiv = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyDiv($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.eq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.eq2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyEqualsTo = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyEqualsTo($receiver, other);
   };
@@ -983,6 +971,9 @@
   PrologWithArgumentationImpl.prototype.anyGreaterThanOrEqualsTo = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyGreaterThanOrEqualsTo($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.id2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.id2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyIf = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyIf($receiver, other);
   };
@@ -1013,6 +1004,12 @@
   PrologWithArgumentationImpl.prototype.anyMinus = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyMinus($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.neq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.neq2($receiver, right);
+  };
+  PrologWithArgumentationImpl.prototype.nid2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.nid2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyNonGreaterThan = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyNonGreaterThan($receiver, other);
   };
@@ -1724,7 +1721,7 @@
         switch (this.state_0) {
           case 0:
             this.state_0 = 2;
-            this.result_0 = this.local$$receiver.yieldAll_swo9gw$(map(this.local$closure$solver.solve(this.local$closure$goal), DynamicLoader$AbstractWithLib$solve$lambda$lambda(this.local$closure$request)), this);
+            this.result_0 = this.local$$receiver.yieldAll_swo9gw$(map(this.local$closure$solver.solveWithOptions(this.local$closure$goal, SolveOptions.Companion.someEagerlyWithTimeout(1000, Long$Companion$MAX_VALUE)), DynamicLoader$AbstractWithLib$solve$lambda$lambda(this.local$closure$request)), this);
             if (this.result_0 === COROUTINE_SUSPENDED)
               return COROUTINE_SUSPENDED;
             continue;
@@ -3777,7 +3774,7 @@
       var tmp$_2 = to(AppendOptimized_getInstance().signature, AppendOptimized_getInstance());
       var tmp$_3 = to(AssertAll_getInstance().signature, AssertAll_getInstance());
       var $this = ArgumentHash_getInstance();
-      return tmp$_1.aliased(tmp$, mapOf_0([tmp$_2, tmp$_3, to($this.signature, $this.wrappedImplementation)]), tmp$_0);
+      return tmp$_1.aliased(tmp$, mapOf_0([tmp$_2, tmp$_3, to($this.signature, $this.wrappedImplementation), to(Contains_getInstance().signature, Contains_getInstance()), to(ContainsAny_getInstance().signature, ContainsAny_getInstance())]), tmp$_0);
     }
   });
   Object.defineProperty(UtilsBase.prototype, 'baseFlags', {
@@ -3984,6 +3981,206 @@
       new ArgumentHash();
     }return ArgumentHash_instance;
   }
+  function Contains() {
+    Contains_instance = this;
+    this.signature = new Signature('contains', 2);
+  }
+  function Coroutine$Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$closure$list = closure$list_0;
+    this.local$closure$elem = closure$elem_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$Contains$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$Contains$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$Contains$solve$lambda.prototype.constructor = Coroutine$Contains$solve$lambda;
+  Coroutine$Contains$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            var tmp$ = this.local$closure$request;
+            var $receiver = this.local$closure$list.toList();
+            var any$result;
+            any$break: do {
+              var tmp$_0;
+              if (Kotlin.isType($receiver, Collection) && $receiver.isEmpty()) {
+                any$result = false;
+                break any$break;
+              }tmp$_0 = $receiver.iterator();
+              while (tmp$_0.hasNext()) {
+                var element = tmp$_0.next();
+                var closure$elem = this.local$closure$elem;
+                if (Unificator.Companion.default.match(element, closure$elem)) {
+                  any$result = true;
+                  break any$break;
+                }}
+              any$result = false;
+            }
+             while (false);
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(tmp$.replyWithCondition(any$result, void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  Contains.prototype.solve = function (request) {
+    var elem = request.arguments.get_za3lpa$(0);
+    var list = request.arguments.get_za3lpa$(1);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }return sequence(Contains$solve$lambda(request, list, elem));
+  };
+  Contains.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'Contains',
+    interfaces: [Primitive]
+  };
+  var Contains_instance = null;
+  function Contains_getInstance() {
+    if (Contains_instance === null) {
+      new Contains();
+    }return Contains_instance;
+  }
+  function ContainsAny() {
+    ContainsAny_instance = this;
+    this.signature = new Signature('contains_any', 2);
+  }
+  function Coroutine$ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$closure$list = closure$list_0;
+    this.local$closure$elemList = closure$elemList_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$ContainsAny$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$ContainsAny$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$ContainsAny$solve$lambda.prototype.constructor = Coroutine$ContainsAny$solve$lambda;
+  Coroutine$ContainsAny$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            var tmp$ = this.local$closure$request;
+            var $receiver = this.local$closure$list.toSequence();
+            var any$result;
+            any$break: do {
+              var tmp$_0;
+              tmp$_0 = $receiver.iterator();
+              loop_label: while (tmp$_0.hasNext()) {
+                var element = tmp$_0.next();
+                var $receiver_0 = this.local$closure$elemList.toSequence();
+                var any$result_0;
+                any$break_0: do {
+                  var tmp$_1;
+                  tmp$_1 = $receiver_0.iterator();
+                  while (tmp$_1.hasNext()) {
+                    var element_0 = tmp$_1.next();
+                    if (Unificator.Companion.default.match(element, element_0)) {
+                      any$result_0 = true;
+                      break any$break_0;
+                    }}
+                  any$result_0 = false;
+                }
+                 while (false);
+                if (any$result_0) {
+                  any$result = true;
+                  break any$break;
+                }}
+              any$result = false;
+            }
+             while (false);
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(tmp$.replyWithCondition(any$result, void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  ContainsAny.prototype.solve = function (request) {
+    var elemList = request.arguments.get_za3lpa$(0);
+    var list = request.arguments.get_za3lpa$(1);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }if (!Kotlin.isType(elemList, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }return sequence(ContainsAny$solve$lambda(request, list, elemList));
+  };
+  ContainsAny.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'ContainsAny',
+    interfaces: [Primitive]
+  };
+  var ContainsAny_instance = null;
+  function ContainsAny_getInstance() {
+    if (ContainsAny_instance === null) {
+      new ContainsAny();
+    }return ContainsAny_instance;
+  }
   function MetaInterpreterLib() {
     MetaInterpreterLib_instance = this;
     this.$delegate_3wovwi$_0 = Library.Companion.aliased('prolog.argumentation.meta', void 0, parse_2(Theory.Companion, trimIndent('\n        % with_facts_and_length/3\n        with_facts_and_length(X, Y, L) :-\n            solve(X, R),\n            recover_facts(R, Y),\n            length(Y, L).\n\n        % lenght/2\n\n        length([], 0).\n        length([_|T], X) :- length(T, Y), X is Y + 1.\n\n        % recover_facts/2\n\n        recover_facts([], []) :- !.\n        recover_facts([H|T], C) :-\n            is_list(H), !,\n            recover_facts(T, TC),\n            recover_facts(H, HC),\n            append(TC, HC, C).\n        recover_facts([H|T], C) :-\n            \\+ is_list(H),\n            recover_facts(T, TC),\n            evaluate(H, HC),\n            append(TC, HC, C).\n\n        evaluate(user_fact(X), [X]) :- !.\n        evaluate(_, []) :- !.\n\n        % solve/2\n\n        solve((A,B), Result) :- !,\n            solve(A, ARes),\n            solve(B, BRes),\n            append(ARes, BRes, Result).\n\n        solve((A;B), Result) :- !,\n            solve(A, Result);\n            solve(B, Result).\n\n        solve(member(A, B), [system_predicate]) :- !,\n            call(member(A, B)).\n\n        solve(\\+(A), [not(A)]) :- !,\n            call(\\+(A)).\n\n        solve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n            call((A)\\=(B)).\n\n        solve(A, [system_predicate]) :-\n            catch(clause(A, _), B, true),\n            \\+ var(B), !,\n            call(A).\n\n        solve(A, [A]) :-\n            \\+ clause(A, B), !,\n            call(A).\n\n        solve(A, [A|[Res]]) :-\n            clause(A, B),\n            solve(B, Res).\n\n        % is_list/1\n\n        is_list(X) :- var(X), !, fail.\n        is_list([]).\n        is_list([_|T]) :- is_list(T).\n        \n        % fetch_argument_facts/2\n        \n        fetch_argument_facts(Conclusion, Facts) :-\n            argument([R, TR, [Conclusion]]),\n            findall(user_fact(Fact), \n                support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n            Facts).\n        ')));
@@ -4083,7 +4280,12 @@
   function attacks$lambda$lambda(it) {
     return it.isYes;
   }
-  function attacks$lambda$lambda_0(closure$arguments, this$) {
+  function attacks$lambda$lambda_0(this$) {
+    return function (it) {
+      return new Pair(ensureNotNull(it.substitution.get_11rb$(this$.X)), ensureNotNull(it.substitution.get_11rb$(this$.Y)));
+    };
+  }
+  function attacks$lambda$lambda_1(closure$arguments) {
     return function (solution) {
       var $receiver = closure$arguments;
       var first$result;
@@ -4092,8 +4294,7 @@
         tmp$ = $receiver.iterator();
         while (tmp$.hasNext()) {
           var element = tmp$.next();
-          var this$_0 = this$;
-          if (Unificator.Companion.default.match(element.termRepresentation(), ensureNotNull(solution.substitution.get_11rb$(this$_0.X)))) {
+          if (element.hashCode() === solution.first.hashCode()) {
             first$result = element;
             break first$break;
           }}
@@ -4108,8 +4309,7 @@
         tmp$_1 = $receiver_0.iterator();
         while (tmp$_1.hasNext()) {
           var element_0 = tmp$_1.next();
-          var this$_1 = this$;
-          if (Unificator.Companion.default.match(element_0.termRepresentation(), ensureNotNull(solution.substitution.get_11rb$(this$_1.Y)))) {
+          if (element_0.hashCode() === solution.second.hashCode()) {
             first$result_0 = element_0;
             break first$break;
           }}
@@ -4121,7 +4321,7 @@
   }
   function attacks$lambda(this$attacks, closure$context, closure$arguments) {
     return function ($receiver) {
-      return map(filter(this$attacks.solve($receiver.stringInvoke('context_check', closure$context, [$receiver.stringInvoke('attack', $receiver._, [$receiver.X, $receiver.Y, $receiver._])])), attacks$lambda$lambda), attacks$lambda$lambda_0(closure$arguments, $receiver));
+      return map(map(filter(this$attacks.solve($receiver.stringInvoke('context_check', closure$context, [$receiver.stringInvoke('attack', $receiver._, [$receiver.X, $receiver.Y, $receiver._])])), attacks$lambda$lambda), attacks$lambda$lambda_0($receiver)), attacks$lambda$lambda_1(closure$arguments));
     };
   }
   function attacks($receiver, context, arguments_0) {
@@ -4129,15 +4329,15 @@
       return emptyList();
     return toList(prolog(attacks$lambda($receiver, context, arguments_0)));
   }
-  function supports$lambda$lambda$lambda(it) {
+  function supports$lambda$lambda(it) {
     return it.isYes;
   }
-  function supports$lambda$lambda$lambda_0(this$) {
+  function supports$lambda$lambda_0(this$) {
     return function (it) {
-      return ensureNotNull(it.substitution.get_11rb$(this$.X));
+      return new Pair(ensureNotNull(it.substitution.get_11rb$(this$.X)), ensureNotNull(it.substitution.get_11rb$(this$.Y)));
     };
   }
-  function supports$lambda$lambda$lambda_1(closure$arguments, closure$argument) {
+  function supports$lambda$lambda_1(closure$arguments) {
     return function (solution) {
       var $receiver = closure$arguments;
       var first$result;
@@ -4146,33 +4346,40 @@
         tmp$ = $receiver.iterator();
         while (tmp$.hasNext()) {
           var element = tmp$.next();
-          if (Unificator.Companion.default.match(element.termRepresentation(), solution)) {
+          if (element.hashCode() === solution.second.hashCode()) {
             first$result = element;
             break first$break;
           }}
         throw new NoSuchElementException_init('Collection contains no element matching the predicate.');
       }
        while (false);
-      var $receiver_0 = new Support(first$result, closure$argument);
-      closure$argument.supports.add_11rb$($receiver_0.supporter);
-      return $receiver_0;
+      var $receiver_0 = first$result;
+      var $receiver_1 = closure$arguments;
+      var first$result_0;
+      first$break: do {
+        var tmp$_0;
+        tmp$_0 = $receiver_1.iterator();
+        while (tmp$_0.hasNext()) {
+          var element_0 = tmp$_0.next();
+          if (element_0.hashCode() === solution.first.hashCode()) {
+            first$result_0 = element_0;
+            break first$break;
+          }}
+        throw new NoSuchElementException_init('Collection contains no element matching the predicate.');
+      }
+       while (false);
+      var $receiver_2 = new Support(first$result_0, $receiver_0);
+      $receiver_0.supports.add_11rb$($receiver_2.supporter);
+      return $receiver_2;
     };
   }
-  function supports$lambda$lambda(this$supports, closure$context, closure$argument, closure$arguments) {
+  function supports$lambda(this$supports, closure$context, closure$arguments) {
     return function ($receiver) {
-      return toList(map(map(filter(this$supports.solve($receiver.stringInvoke('context_check', closure$context, [$receiver.stringInvoke('support', $receiver.X, [closure$argument.termRepresentation()])])), supports$lambda$lambda$lambda), supports$lambda$lambda$lambda_0($receiver)), supports$lambda$lambda$lambda_1(closure$arguments, closure$argument)));
+      return toList(map(map(filter(this$supports.solve($receiver.stringInvoke('context_check', closure$context, [$receiver.stringInvoke('support', $receiver.X, [$receiver.Y])])), supports$lambda$lambda), supports$lambda$lambda_0($receiver)), supports$lambda$lambda_1(closure$arguments)));
     };
   }
   function supports($receiver, context, arguments_0) {
-    var destination = ArrayList_init_0();
-    var tmp$;
-    tmp$ = arguments_0.iterator();
-    while (tmp$.hasNext()) {
-      var element = tmp$.next();
-      var list = prolog(supports$lambda$lambda($receiver, context, element, arguments_0));
-      addAll(destination, list);
-    }
-    return destination;
+    return prolog(supports$lambda($receiver, context, arguments_0));
   }
   function labels$checkFunctor$lambda$lambda(it) {
     return it.isYes;
@@ -4204,7 +4411,7 @@
     }
     return destination;
   }
-  function Argument(rules, topRule, conclusion, groundings, defeasibleRules, defeasiblePremises, lastDefeasibleRules) {
+  function Argument(rules, topRule, conclusion, groundings, defeasibleRules, defeasiblePremises, lastDefeasibleRules, term) {
     Argument$Companion_getInstance();
     if (groundings === void 0)
       groundings = emptyList();
@@ -4214,6 +4421,8 @@
       defeasiblePremises = emptyList();
     if (lastDefeasibleRules === void 0)
       lastDefeasibleRules = emptyList();
+    if (term === void 0)
+      term = null;
     this.rules = rules;
     this.topRule = topRule;
     this.conclusion = conclusion;
@@ -4221,9 +4430,15 @@
     this.defeasibleRules = defeasibleRules;
     this.defeasiblePremises = defeasiblePremises;
     this.lastDefeasibleRules = lastDefeasibleRules;
+    this.term_0 = term;
     this.identifier = '';
     this.supports = ArrayList_init_0();
   }
+  Argument.prototype.hashCode = function () {
+    var $receiver = this.term_0;
+    var tmp$;
+    return (tmp$ = $receiver != null ? hashCode($receiver) : null) != null ? tmp$ : 0;
+  };
   Object.defineProperty(Argument.prototype, 'descriptor', {
     configurable: true,
     get: function () {
@@ -4253,7 +4468,8 @@
     }
   });
   Argument.prototype.termRepresentation = function () {
-    return parse_1(Struct.Companion, '[' + this.rules + ', ' + this.topRule + ', [' + this.conclusion + '], ' + this.groundings + ', [' + this.lastDefeasibleRules + ', ' + this.defeasibleRules + ', ' + this.defeasiblePremises + ']]');
+    var tmp$;
+    return (tmp$ = this.term_0) != null ? tmp$ : parse_1(Struct.Companion, '[' + this.rules + ', ' + this.topRule + ', [' + this.conclusion + '], ' + this.groundings + ', [' + this.lastDefeasibleRules + ', ' + this.defeasibleRules + ', ' + this.defeasiblePremises + ']]');
   };
   Argument.prototype.toString = function () {
     return 'argument(' + this.termRepresentation() + ')';
@@ -4322,7 +4538,7 @@
     var argDefeasiblePremises = Argument$Companion$of$argDefeasiblePremises(termAsList, toStringList);
     var argLastDefeasibleRules = Argument$Companion$of$argLastDefeasibleRules(termAsList, toStringList);
     var it = termAsList(term);
-    return new Argument(argRules(it), argTopRule(it), argConclusion(it), argGroundings(it), argDefeasibleRules(it), argDefeasiblePremises(it), argLastDefeasibleRules(it));
+    return new Argument(argRules(it), argTopRule(it), argConclusion(it), argGroundings(it), argDefeasibleRules(it), argDefeasiblePremises(it), argLastDefeasibleRules(it), term);
   };
   Argument$Companion.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4361,22 +4577,14 @@
   Argument.prototype.component7 = function () {
     return this.lastDefeasibleRules;
   };
-  Argument.prototype.copy_2b7ur7$ = function (rules, topRule, conclusion, groundings, defeasibleRules, defeasiblePremises, lastDefeasibleRules) {
-    return new Argument(rules === void 0 ? this.rules : rules, topRule === void 0 ? this.topRule : topRule, conclusion === void 0 ? this.conclusion : conclusion, groundings === void 0 ? this.groundings : groundings, defeasibleRules === void 0 ? this.defeasibleRules : defeasibleRules, defeasiblePremises === void 0 ? this.defeasiblePremises : defeasiblePremises, lastDefeasibleRules === void 0 ? this.lastDefeasibleRules : lastDefeasibleRules);
+  Argument.prototype.component8_0 = function () {
+    return this.term_0;
   };
-  Argument.prototype.hashCode = function () {
-    var result = 0;
-    result = result * 31 + Kotlin.hashCode(this.rules) | 0;
-    result = result * 31 + Kotlin.hashCode(this.topRule) | 0;
-    result = result * 31 + Kotlin.hashCode(this.conclusion) | 0;
-    result = result * 31 + Kotlin.hashCode(this.groundings) | 0;
-    result = result * 31 + Kotlin.hashCode(this.defeasibleRules) | 0;
-    result = result * 31 + Kotlin.hashCode(this.defeasiblePremises) | 0;
-    result = result * 31 + Kotlin.hashCode(this.lastDefeasibleRules) | 0;
-    return result;
+  Argument.prototype.copy_fhhptr$ = function (rules, topRule, conclusion, groundings, defeasibleRules, defeasiblePremises, lastDefeasibleRules, term) {
+    return new Argument(rules === void 0 ? this.rules : rules, topRule === void 0 ? this.topRule : topRule, conclusion === void 0 ? this.conclusion : conclusion, groundings === void 0 ? this.groundings : groundings, defeasibleRules === void 0 ? this.defeasibleRules : defeasibleRules, defeasiblePremises === void 0 ? this.defeasiblePremises : defeasiblePremises, lastDefeasibleRules === void 0 ? this.lastDefeasibleRules : lastDefeasibleRules, term === void 0 ? this.term_0 : term);
   };
   Argument.prototype.equals = function (other) {
-    return this === other || (other !== null && (typeof other === 'object' && (Object.getPrototypeOf(this) === Object.getPrototypeOf(other) && (Kotlin.equals(this.rules, other.rules) && Kotlin.equals(this.topRule, other.topRule) && Kotlin.equals(this.conclusion, other.conclusion) && Kotlin.equals(this.groundings, other.groundings) && Kotlin.equals(this.defeasibleRules, other.defeasibleRules) && Kotlin.equals(this.defeasiblePremises, other.defeasiblePremises) && Kotlin.equals(this.lastDefeasibleRules, other.lastDefeasibleRules)))));
+    return this === other || (other !== null && (typeof other === 'object' && (Object.getPrototypeOf(this) === Object.getPrototypeOf(other) && (Kotlin.equals(this.rules, other.rules) && Kotlin.equals(this.topRule, other.topRule) && Kotlin.equals(this.conclusion, other.conclusion) && Kotlin.equals(this.groundings, other.groundings) && Kotlin.equals(this.defeasibleRules, other.defeasibleRules) && Kotlin.equals(this.defeasiblePremises, other.defeasiblePremises) && Kotlin.equals(this.lastDefeasibleRules, other.lastDefeasibleRules) && Kotlin.equals(this.term_0, other.term_0)))));
   };
   function Attack(attacker, target, type, on) {
     if (type === void 0)
@@ -5032,7 +5240,7 @@
   }
   function ArgumentationGraph() {
     ArgumentationGraph_instance = this;
-    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tbuildArgumentsFromEmptyRules,\n    \tfindall([RuleID, RuleBody, RuleHead], (\n    \t    parser::classic_rule(RuleID, RuleBody, RuleHead),\n    \t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n        ), Rules),\n    \tbuildArgumentsFromRules(b, Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                parser::classic_rule(PremiseID, Premise),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(conc(Premise) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(newConc(a, Premise)),\n                utils::hash(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]), Id),\n                context_assert(arg(Id) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromEmptyRules :-\n        findall(\n            _,\n            (\n                emptyRule([RuleID, RulePrem, RuleHead]),\n                checkStrict(RuleID, DefRule),\n                ground(RuleHead),\n                context_assert(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(conc(Premise) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(newConc(a, Premise)),\n                utils::hash(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]), Id),\n                context_assert(arg(Id) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, Body, RuleHead]) :-\n        parser::classic_rule(RuleID, Body, RuleHead),\n        \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n        checkPrologClauses(Body).\n    checkPrologClauses([]) :- !.\n    checkPrologClauses([~(_)|T]) :- checkPrologClauses(T), !.\n    checkPrologClauses([prolog(Check)|T]) :-\n        (callable(Check) -> call(Check); Check),\n        checkPrologClauses(T).\n    clean(Tn, Rules) :-\n        invert(Tn, Tx),\n        context_retract(newConc(Tx, _)),\n        buildArgumentsFromRules(Tx, Rules, Rules, n).\n    check_new(Tn, H) :-\n        copy_term(H, [_, RuleBody, _]),\n        member(X, RuleBody),\n        invert(Tn, Tx),\n        context_check(newConc(Tx, [X])).\n    invert(a, b).\n    invert(b, a).\n    buildArgumentsFromRules(_, Rules, [], n).\n    buildArgumentsFromRules(Tn, Rules, [], y) :- clean(Tn, Rules).\n    buildArgumentsFromRules(Tn, Rules, [H|T], _) :-\n        once(check_new(Tn, H)),\n        copy_term(H, HH),\n        findall(true, buildArgumentsFromRule(Tn, HH), R),\n        R \\== [],\n        buildArgumentsFromRules(Tn, Rules, T, y), !.\n    buildArgumentsFromRules(Tn, Rules, [_|T], X) :-\n        buildArgumentsFromRules(Tn, Rules, T, X).\n    buildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleBody, [], [], SupportRules, ArgSupports),\n    \t\\+ member(RuleID, SupportRules),\n    \tground(RuleHead),\n    \tutils::sort([RuleID|SupportRules], SortedPremises),\n    \t\\+ context_check(argument([SortedPremises, RuleID, RuleHead, RuleBody, _])),\n    \tbuildArgumentInfo(ArgSupports, RuleID, Info),\n        NewArgument = [SortedPremises, RuleID, RuleHead, RuleBody, Info],\n        context_assert(conc(RuleHead) :- argument(NewArgument)),\n        context_assert(newConc(Tn, RuleHead)),\n    \tcontext_assert(argument(NewArgument)),\n    \tutils::hash(argument(NewArgument), Id),\n    \tcontext_assert(arg(Id) :- argument(NewArgument)),\n    \tsupports(NewArgument, ArgSupports).\n    supports(Argument, Supports) :-\n        findall(_, (\n            member(S, Supports),\n            context_assert(support(S, Argument))\n        ), _).\n    checkStrict(Id, [Id]) :- \\+ parser::check_strict(Id).\n    checkStrict(Id, []) :- parser::check_strict(Id).\n    buildArgumentInfo(Supports, RuleId, [LastDefRules, DefRules, DefPrem]) :-\n        defeasibleRules(RuleId, Supports, DefRules),\n        ordinaryPremises(Supports, DefPrem),\n        lastDefeasibleRules(Supports, RuleId, LastDefRules).\n    ordinaryPremises(Supports, DefPrem) :-\n        findall(Def, member([_, _, _, _, [_, _, Def]], Supports), Prem),\n        utils::appendLists(Prem, TempPrem),\n        utils::sortDistinct(TempPrem, DefPrem).\n    defeasibleRules(RuleId, Supports, DefRules) :-\n    \tfindall(Def, member([_, _, _, _, [_, Def, _]], Supports), UnsortedRules),\n    \tcheckStrict(RuleId, DefRule),\n    \tutils::appendLists([DefRule|UnsortedRules], TempRules),\n    \tutils::sortDistinct(TempRules, DefRules).\n    lastDefeasibleRules(_, TopRule, [TopRule]) :-\n        TopRule \\== none, \\+ parser::check_strict(TopRule).\n    lastDefeasibleRules(Supports, TopRule, LastRules) :-\n    \tparser::check_strict(TopRule),\n    \tfindall(Def, member([_, _, _, _, [Def, _, _]], Supports), Res),\n    \tutils::appendLists(Res, TempLastRules),\n    \tutils::sortDistinct(TempLastRules, LastRules).\n    ruleBodyIsSupported([], ResultPremises, ResultSupports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([~(_)|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([prolog(Check)|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([Statement|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n        context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, Info]))),\n    \tappend(ArgumentID, Premises, NewPremises),\n    \truleBodyIsSupported(Others, NewPremises, [[ArgumentID, RuleID, [Statement], Body, Info]|Supports], ResultPremises, ResultSupports).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Head, Conf).\n    findPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n        member(~(Conf), Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\n    buildAttacks :-\n    \tbuildDirectAttacks,\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks :-\n        findall(_, buildDirectAttack, _).\n    buildDirectAttack :-\n        context_check(argument(A)),\n        findPossibleAttackers(A, BB),\n    \tcontext_check(clause(conc(BB), argument(B))),\n    \tA \\== B,\n        attacks(T, B, A),\n    \t\\+ context_check(attack(T, B, A, A)),\n    \tcontext_assert(attack(T, B, A, A)),\n    \tutils::hash(argument(A), IdA),\n    \tutils::hash(argument(B), IdB),\n    \tcontext_assert(att(IdB, IdA) :- attack(T, B, A, A)),\n    \tfail.\n    buildDirectAttack.\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_assert(attack(T, A, C, D)),\n        utils::hash(argument(A), IdA),\n        utils::hash(argument(C), IdC),\n        context_assert(att(IdA, IdC) :- attack(T, B, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tmember(~(RuleHeadA), Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tmember(~(RuleHeadA), Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    check(-Atom).\n    conflict([Atom], [-Atom]) :- \\+ check(Atom).\n    conflict([-Atom], [Atom]).\n    conflict([o(Atom)], [o(-Atom)]).\n    conflict([o(-Atom)], [o(Atom)]).\n    conflict([o(Lit)], [-o(Lit)]).\n    conflict([-o(Lit)], [o(Lit)]).\n    conflict([p(Atom)], [o(-Atom)]).\n    conflict([o(-Atom)], [p(Atom)]).\n    conflict([p(-Atom)], [o(Atom)]).\n    conflict([o(Atom)], [p(-Atom)]).\n    conflict([sup(X, Y)], [sup(Y, X)]).\n        ');
+    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tbuildArgumentsFromEmptyRules,\n    \tfindall([RuleID, RuleBody, RuleHead], (\n    \t    parser::classic_rule(RuleID, RuleBody, RuleHead),\n    \t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n        ), Rules),\n        findall(X, context_check(newConc(a, [X])), N),\n    \tbuildArgumentsFromRules(N, b, Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                parser::classic_rule(PremiseID, Premise),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(conc(Premise) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(newConc(a, Premise)),\n                utils::hash(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]), Id),\n                context_assert(arg(Id) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromEmptyRules :-\n        findall(\n            _,\n            (\n                emptyRule([RuleID, RulePrem, RuleHead]),\n                checkStrict(RuleID, DefRule),\n                ground(RuleHead),\n                context_assert(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(conc(RuleHead) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(newConc(a, RuleHead)),\n                utils::hash(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]), Id),\n                context_assert(arg(Id) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, Body, RuleHead]) :-\n        parser::classic_rule(RuleID, Body, RuleHead),\n        \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n        checkPrologClauses(Body).\n    checkPrologClauses([]) :- !.\n    checkPrologClauses([~(_)|T]) :- checkPrologClauses(T), !.\n    checkPrologClauses([prolog(Check)|T]) :-\n        (callable(Check) -> call(Check); Check),\n        checkPrologClauses(T).\n    clean(Tn, Rules) :-\n        invert(Tn, Tx),\n        context_retract(newConc(Tx, _)),\n        findall(X, context_check(newConc(Tn, [X])), N),\n        buildArgumentsFromRules(N, Tx, Rules, Rules, n).\n    invert(a, b).\n    invert(b, a).\n    buildArgumentsFromRules(_, _, Rules, [], n) :- !.\n    buildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\n    buildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n        utils::contains_any(Body, N),\n        findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n        R \\== [],\n        buildArgumentsFromRules(N, Tn, Rules, T, y), !.\n    buildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n        buildArgumentsFromRules(N, Tn, Rules, T, X).\n    buildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n        context_assert(newConc(Tn, RuleHead)).\n    checkStrict(Id, []) :- parser::check_strict(Id), !.\n    checkStrict(Id, [Id]).\n    defRules(Id, Def, Def) :- parser::check_strict(Id), !.\n    defRules(Id, Def, [Id|Def]).\n    lastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\n    lastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\n    argumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n        utils::sortDistinct(Prem, FPrem),\n        defRules(RuleId, Def, NDef),\n        utils::sortDistinct(NDef, FDef),\n        lastDefRules(RuleId, LDef, NLDef),\n        utils::sortDistinct(NLDef, FLDef).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n        ground(RuleHead),\n        \\+ context_check(clause(conc(RuleHead), argument([_, RuleID, RuleHead, RuleBody, _]))),\n        utils::appendLists(TAll, All),\n        \\+ utils::contains(RuleID, All),\n        utils::appendLists(TLDef, LDef),\n        utils::appendLists(TDef, Def),\n        utils::appendLists(TPrem, Prem),\n        argumentInfo(RuleID, LDef, Def, Prem, Info),\n        utils::sort([RuleID|All], Rules),\n        Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n        context_assert(conc(RuleHead) :- argument(Argument)),\n        context_assert(argument(Argument)),\n        utils::hash(argument(Argument), Id),\n        context_assert(arg(Id) :- argument(Argument)).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\n    ruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n        context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n    \truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n    \tcontext_assert(support([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument)).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Conf, Head, Guard).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Conf, Head).\n    findPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n        member(~(Conf), Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\n    buildAttacks :-\n    \tbuildDirectAttacks,\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks :-\n        findall(_, buildDirectAttack, _).\n    buildDirectAttack :-\n        context_check(argument(A)),\n        findPossibleAttackers(A, BB),\n    \tcontext_check(clause(conc(BB), argument(B))),\n    \tA \\== B,\n        attacks(T, B, A),\n    \t\\+ context_check(attack(T, B, A, A)),\n    \tcontext_assert(attack(T, B, A, A)),\n    \tutils::hash(argument(A), IdA),\n    \tutils::hash(argument(B), IdB),\n    \tcontext_assert(att(IdB, IdA) :- attack(T, B, A, A)),\n    \tfail.\n    buildDirectAttack.\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_assert(attack(T, A, C, D)),\n        utils::hash(argument(A), IdA),\n        utils::hash(argument(C), IdC),\n        context_assert(att(IdA, IdC) :- attack(T, B, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB).\n    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB, Guard),\n        (callable(Guard) -> call(Guard); Guard).\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tutils::contains(~(RuleHeadA), Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tutils::contains(~(RuleHeadA), Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    check(-Atom).\n    conflict([Atom], [-Atom]) :- \\+ check(Atom).\n    conflict([-Atom], [Atom]).\n    conflict([o(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [o(Atom)]).\n    conflict([p(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [p(Atom)]).\n    conflict([p(-Atom)], [o(Atom)]).\n    conflict([o(Atom)], [p(-Atom)]) :- \\+ check(Atom).\n    conflict([sup(X, Y)], [sup(Y, X)]).\n        ');
   }
   ArgumentationGraph.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5545,6 +5753,12 @@
   Object.defineProperty(package$utils, 'ArgumentHash', {
     get: ArgumentHash_getInstance
   });
+  Object.defineProperty(package$utils, 'Contains', {
+    get: Contains_getInstance
+  });
+  Object.defineProperty(package$utils, 'ContainsAny', {
+    get: ContainsAny_getInstance
+  });
   var package$meta = package$core.meta || (package$core.meta = {});
   Object.defineProperty(package$meta, 'MetaInterpreterLib', {
     get: MetaInterpreterLib_getInstance
@@ -5808,21 +6022,17 @@
   PrologWithArgumentation.prototype.unifyWithOccurCheck = PrologScopeWithTheories.prototype.unifyWithOccurCheck;
   PrologWithArgumentation.prototype.var1 = PrologScopeWithTheories.prototype.var1;
   PrologWithArgumentation.prototype.write1 = PrologScopeWithTheories.prototype.write1;
-  PrologWithArgumentation.prototype.neq2 = PrologScopeWithTheories.prototype.neq2;
-  PrologWithArgumentation.prototype.nid2 = PrologScopeWithTheories.prototype.nid2;
-  PrologWithArgumentation.prototype.power = PrologScopeWithTheories.prototype.power;
-  PrologWithArgumentation.prototype.eq2 = PrologScopeWithTheories.prototype.eq2;
-  PrologWithArgumentation.prototype.arithNeq2 = PrologScopeWithTheories.prototype.arithNeq2;
-  PrologWithArgumentation.prototype.id2 = PrologScopeWithTheories.prototype.id2;
-  PrologWithArgumentation.prototype.arithEq2 = PrologScopeWithTheories.prototype.arithEq2;
-  PrologWithArgumentation.prototype.pow = PrologScopeWithTheories.prototype.pow;
   PrologWithArgumentation.prototype.anyAnd = PrologScopeWithTheories.prototype.anyAnd;
+  PrologWithArgumentation.prototype.arithEq2 = PrologScopeWithTheories.prototype.arithEq2;
+  PrologWithArgumentation.prototype.arithNeq2 = PrologScopeWithTheories.prototype.arithNeq2;
   PrologWithArgumentation.prototype.substitutionContainsKey = PrologScopeWithTheories.prototype.substitutionContainsKey;
   PrologWithArgumentation.prototype.substitutionContainsValue = PrologScopeWithTheories.prototype.substitutionContainsValue;
   PrologWithArgumentation.prototype.anyDiv = PrologScopeWithTheories.prototype.anyDiv;
+  PrologWithArgumentation.prototype.eq2 = PrologScopeWithTheories.prototype.eq2;
   PrologWithArgumentation.prototype.anyEqualsTo = PrologScopeWithTheories.prototype.anyEqualsTo;
   PrologWithArgumentation.prototype.anyGreaterThan = PrologScopeWithTheories.prototype.anyGreaterThan;
   PrologWithArgumentation.prototype.anyGreaterThanOrEqualsTo = PrologScopeWithTheories.prototype.anyGreaterThanOrEqualsTo;
+  PrologWithArgumentation.prototype.id2 = PrologScopeWithTheories.prototype.id2;
   PrologWithArgumentation.prototype.anyIf = PrologScopeWithTheories.prototype.anyIf;
   PrologWithArgumentation.prototype.anyIfVararg = PrologScopeWithTheories.prototype.anyIfVararg;
   PrologWithArgumentation.prototype.anyImpliedBy = PrologScopeWithTheories.prototype.anyImpliedBy;
@@ -5835,6 +6045,8 @@
   PrologWithArgumentation.prototype.anyMatches = PrologScopeWithTheories.prototype.anyMatches;
   PrologWithArgumentation.prototype.anyMguWith = PrologScopeWithTheories.prototype.anyMguWith;
   PrologWithArgumentation.prototype.anyMinus = PrologScopeWithTheories.prototype.anyMinus;
+  PrologWithArgumentation.prototype.neq2 = PrologScopeWithTheories.prototype.neq2;
+  PrologWithArgumentation.prototype.nid2 = PrologScopeWithTheories.prototype.nid2;
   PrologWithArgumentation.prototype.anyNonGreaterThan = PrologScopeWithTheories.prototype.anyNonGreaterThan;
   PrologWithArgumentation.prototype.anyNonLowerThan = PrologScopeWithTheories.prototype.anyNonLowerThan;
   PrologWithArgumentation.prototype.anyNotEqualsTo = PrologScopeWithTheories.prototype.anyNotEqualsTo;
@@ -5869,9 +6081,9 @@
   PrologWithArgumentationImpl.prototype.anyMguWith = PrologWithArgumentation.prototype.anyMguWith;
   PrologWithArgumentationImpl.prototype.anyUnifyWith = PrologWithArgumentation.prototype.anyUnifyWith;
   PrologWithArgumentationImpl.prototype.list = PrologWithArgumentation.prototype.list;
-  PrologWithArgumentationImpl.prototype.listFrom = PrologWithArgumentation.prototype.listFrom;
-  PrologWithArgumentationImpl.prototype.listFromSequence = PrologWithArgumentation.prototype.listFromSequence;
   PrologWithArgumentationImpl.prototype.listFromIterable = PrologWithArgumentation.prototype.listFromIterable;
+  PrologWithArgumentationImpl.prototype.listFromSequence = PrologWithArgumentation.prototype.listFromSequence;
+  PrologWithArgumentationImpl.prototype.listFrom = PrologWithArgumentation.prototype.listFrom;
   PrologWithArgumentationImpl.prototype.matchAny = PrologWithArgumentation.prototype.matchAny;
   PrologWithArgumentationImpl.prototype.mguWithOccurCheck = PrologWithArgumentation.prototype.mguWithOccurCheck;
   PrologWithArgumentationImpl.prototype.mguAny = PrologWithArgumentation.prototype.mguAny;