@tuprolog/arg2p 0.16.6 → 0.16.7

package/2p-io-lib.js

@@ -1,8 +1,8 @@
 (function (factory) {
   if (typeof define === 'function' && define.amd)
-    define(['exports', './kotlin-kotlin-stdlib.js', './2p-parser-impl.js', './2p-solve.js', './2p-parser-core.js', './2p-core.js', './2p-parser-theory.js', './2p-theory.js', './okio-parent-okio.js', './okio-parent-okio-nodefilesystem.js'], factory);
+    define(['exports', './kotlin-kotlin-stdlib.js', './2p-parser-impl.js', './2p-solve.js', './2p-parser-core.js', './2p-core.js', './okio-parent-okio.js', './2p-parser-theory.js', './2p-theory.js', './okio-parent-okio-nodefilesystem.js'], factory);
   else if (typeof exports === 'object')
-    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-parser-impl.js'), require('./2p-solve.js'), require('./2p-parser-core.js'), require('./2p-core.js'), require('./2p-parser-theory.js'), require('./2p-theory.js'), require('./okio-parent-okio.js'), require('./okio-parent-okio-nodefilesystem.js'));
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-parser-impl.js'), require('./2p-solve.js'), require('./2p-parser-core.js'), require('./2p-core.js'), require('./okio-parent-okio.js'), require('./2p-parser-theory.js'), require('./2p-theory.js'), require('./okio-parent-okio-nodefilesystem.js'));
   else {
     if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
       throw new Error("Error loading module '2p-io-lib'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to '2p-io-lib'.");
@@ -19,115 +19,115 @@
     if (typeof globalThis['2p-core'] === 'undefined') {
       throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to '2p-io-lib'.");
     }
+    if (typeof globalThis['okio-parent-okio'] === 'undefined') {
+      throw new Error("Error loading module '2p-io-lib'. Its dependency 'okio-parent-okio' was not found. Please, check whether 'okio-parent-okio' is loaded prior to '2p-io-lib'.");
+    }
     if (typeof globalThis['2p-parser-theory'] === 'undefined') {
       throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-parser-theory' was not found. Please, check whether '2p-parser-theory' is loaded prior to '2p-io-lib'.");
     }
     if (typeof globalThis['2p-theory'] === 'undefined') {
       throw new Error("Error loading module '2p-io-lib'. Its dependency '2p-theory' was not found. Please, check whether '2p-theory' is loaded prior to '2p-io-lib'.");
     }
-    if (typeof globalThis['okio-parent-okio'] === 'undefined') {
-      throw new Error("Error loading module '2p-io-lib'. Its dependency 'okio-parent-okio' was not found. Please, check whether 'okio-parent-okio' is loaded prior to '2p-io-lib'.");
-    }
     if (typeof globalThis['okio-parent-okio-nodefilesystem'] === 'undefined') {
       throw new Error("Error loading module '2p-io-lib'. Its dependency 'okio-parent-okio-nodefilesystem' was not found. Please, check whether 'okio-parent-okio-nodefilesystem' is loaded prior to '2p-io-lib'.");
     }
-    globalThis['2p-io-lib'] = factory(typeof globalThis['2p-io-lib'] === 'undefined' ? {} : globalThis['2p-io-lib'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-parser-impl'], globalThis['2p-solve'], globalThis['2p-parser-core'], globalThis['2p-core'], globalThis['2p-parser-theory'], globalThis['2p-theory'], globalThis['okio-parent-okio'], globalThis['okio-parent-okio-nodefilesystem']);
+    globalThis['2p-io-lib'] = factory(typeof globalThis['2p-io-lib'] === 'undefined' ? {} : globalThis['2p-io-lib'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-parser-impl'], globalThis['2p-solve'], globalThis['2p-parser-core'], globalThis['2p-core'], globalThis['okio-parent-okio'], globalThis['2p-parser-theory'], globalThis['2p-theory'], globalThis['okio-parent-okio-nodefilesystem']);
   }
-}(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_parser_impl, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_parser_core, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_theory, kotlin_com_squareup_okio_okio, kotlin_com_squareup_okio_okio_nodefilesystem) {
+}(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_parser_impl, kotlin_it_unibo_tuprolog_solve, kotlin_it_unibo_tuprolog_parser_core, kotlin_it_unibo_tuprolog_core, kotlin_com_squareup_okio_okio, kotlin_it_unibo_tuprolog_parser_theory, kotlin_it_unibo_tuprolog_theory, kotlin_com_squareup_okio_okio_nodefilesystem) {
   'use strict';
   //region block: imports
   var VOID = kotlin_kotlin.$_$.b;
   var buildParserFor = kotlin_it_unibo_tuprolog_parser_impl.$_$.v;
-  var Companion_instance = kotlin_it_unibo_tuprolog_solve.$_$.o;
+  var Companion_instance = kotlin_it_unibo_tuprolog_solve.$_$.p;
   var Unit_instance = kotlin_kotlin.$_$.q;
-  var protoOf = kotlin_kotlin.$_$.r7;
-  var equals = kotlin_kotlin.$_$.x6;
-  var FunctionAdapter = kotlin_kotlin.$_$.m6;
-  var isInterface = kotlin_kotlin.$_$.l7;
+  var protoOf = kotlin_kotlin.$_$.s7;
+  var equals = kotlin_kotlin.$_$.y6;
+  var FunctionAdapter = kotlin_kotlin.$_$.n6;
+  var isInterface = kotlin_kotlin.$_$.m7;
   var TextChunkSource = kotlin_it_unibo_tuprolog_parser_impl.$_$.t;
-  var hashCode = kotlin_kotlin.$_$.d7;
-  var initMetadataForClass = kotlin_kotlin.$_$.e7;
-  var CoroutineImpl = kotlin_kotlin.$_$.s5;
-  var THROW_CCE = kotlin_kotlin.$_$.ec;
-  var SequenceScope = kotlin_kotlin.$_$.n8;
-  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.r5;
+  var hashCode = kotlin_kotlin.$_$.e7;
+  var initMetadataForClass = kotlin_kotlin.$_$.f7;
+  var CoroutineImpl = kotlin_kotlin.$_$.t5;
+  var THROW_CCE = kotlin_kotlin.$_$.gc;
+  var SequenceScope = kotlin_kotlin.$_$.o8;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.s5;
   var toParseException = kotlin_it_unibo_tuprolog_parser_core.$_$.j;
   var PrologSyntaxException = kotlin_it_unibo_tuprolog_parser_impl.$_$.j;
-  var initMetadataForLambda = kotlin_kotlin.$_$.h7;
-  var constructCallableReference = kotlin_kotlin.$_$.v6;
+  var initMetadataForLambda = kotlin_kotlin.$_$.i7;
+  var constructCallableReference = kotlin_kotlin.$_$.w6;
   var toOperatorTable = kotlin_it_unibo_tuprolog_parser_core.$_$.i;
   var Companion_instance_0 = kotlin_it_unibo_tuprolog_core.$_$.t;
   var PrologTermParserVisitor = kotlin_it_unibo_tuprolog_parser_core.$_$.b;
-  var sequence = kotlin_kotlin.$_$.t9;
+  var sequence = kotlin_kotlin.$_$.u9;
   var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.v;
-  var AbstractLibrary = kotlin_it_unibo_tuprolog_solve.$_$.l2;
-  var Companion_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.h1;
+  var AbstractLibrary = kotlin_it_unibo_tuprolog_solve.$_$.n2;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.i1;
   var listOf = kotlin_kotlin.$_$.x3;
   var collectionSizeOrDefault = kotlin_kotlin.$_$.q2;
   var ArrayList_init_$Create$ = kotlin_kotlin.$_$.s;
-  var to = kotlin_kotlin.$_$.rc;
-  var initMetadataForObject = kotlin_kotlin.$_$.i7;
+  var to = kotlin_kotlin.$_$.uc;
+  var initMetadataForObject = kotlin_kotlin.$_$.j7;
   var Companion_instance_1 = kotlin_kotlin.$_$.o;
   var asSequence = kotlin_kotlin.$_$.n2;
-  var map = kotlin_kotlin.$_$.l9;
+  var map = kotlin_kotlin.$_$.m9;
   var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.k;
-  var toSet = kotlin_kotlin.$_$.ca;
-  var initMetadataForCompanion = kotlin_kotlin.$_$.f7;
-  var THROW_IAE = kotlin_kotlin.$_$.fc;
-  var enumEntries = kotlin_kotlin.$_$.t5;
-  var Enum = kotlin_kotlin.$_$.ub;
-  var toString = kotlin_kotlin.$_$.u7;
+  var toSet = kotlin_kotlin.$_$.da;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.g7;
+  var THROW_IAE = kotlin_kotlin.$_$.hc;
+  var enumEntries = kotlin_kotlin.$_$.u5;
+  var Enum = kotlin_kotlin.$_$.wb;
+  var toString = kotlin_kotlin.$_$.v7;
   var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.i1;
-  var startsWith = kotlin_kotlin.$_$.cb;
-  var initMetadataForInterface = kotlin_kotlin.$_$.g7;
-  var AbstractOutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.e2;
-  var AbstractInputChannel = kotlin_it_unibo_tuprolog_solve.$_$.d2;
+  var startsWith = kotlin_kotlin.$_$.db;
+  var initMetadataForInterface = kotlin_kotlin.$_$.h7;
+  var AbstractOutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.g2;
+  var AbstractInputChannel = kotlin_it_unibo_tuprolog_solve.$_$.f2;
   var ArrayDeque_init_$Create$ = kotlin_kotlin.$_$.r;
   var _Char___init__impl__6a9atx = kotlin_kotlin.$_$.c;
   var Char__toInt_impl_vasixd = kotlin_kotlin.$_$.g;
-  var numberToChar = kotlin_kotlin.$_$.o7;
-  var Char = kotlin_kotlin.$_$.rb;
+  var numberToChar = kotlin_kotlin.$_$.p7;
+  var Char = kotlin_kotlin.$_$.tb;
   var toString_0 = kotlin_kotlin.$_$.h;
   var TuPrologException_init_$Init$ = kotlin_it_unibo_tuprolog_core.$_$.h1;
-  var objectCreate = kotlin_kotlin.$_$.q7;
-  var captureStack = kotlin_kotlin.$_$.o6;
+  var objectCreate = kotlin_kotlin.$_$.r7;
+  var captureStack = kotlin_kotlin.$_$.p6;
   var TuPrologException_init_$Init$_0 = kotlin_it_unibo_tuprolog_core.$_$.i1;
   var TuPrologException = kotlin_it_unibo_tuprolog_core.$_$.l1;
-  var Companion_instance_2 = kotlin_it_unibo_tuprolog_solve.$_$.a1;
-  var Companion_instance_3 = kotlin_it_unibo_tuprolog_solve.$_$.b1;
-  var Expected_URL_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.m;
-  var Predicative = kotlin_it_unibo_tuprolog_solve.$_$.q2;
-  var Predicative_0 = kotlin_it_unibo_tuprolog_solve.$_$.w2;
-  var NonBacktrackable = kotlin_it_unibo_tuprolog_solve.$_$.n2;
-  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_solve.$_$.j1;
-  var InputChannel = kotlin_it_unibo_tuprolog_solve.$_$.f2;
-  var OutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.g2;
-  var NonBacktrackable_0 = kotlin_it_unibo_tuprolog_solve.$_$.v2;
+  var Companion_instance_2 = kotlin_it_unibo_tuprolog_solve.$_$.b1;
+  var Companion_instance_3 = kotlin_it_unibo_tuprolog_solve.$_$.c1;
+  var Expected_URL_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.n;
+  var Predicative = kotlin_it_unibo_tuprolog_solve.$_$.s2;
+  var Predicative_0 = kotlin_it_unibo_tuprolog_solve.$_$.x2;
+  var NonBacktrackable = kotlin_it_unibo_tuprolog_solve.$_$.p2;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_solve.$_$.k1;
+  var InputChannel = kotlin_it_unibo_tuprolog_solve.$_$.h2;
+  var OutputChannel = kotlin_it_unibo_tuprolog_solve.$_$.i2;
+  var NonBacktrackable_0 = kotlin_it_unibo_tuprolog_solve.$_$.w2;
   var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.l1;
-  var IllegalStateException = kotlin_kotlin.$_$.xb;
+  var IllegalStateException = kotlin_kotlin.$_$.zb;
   var Atom = kotlin_it_unibo_tuprolog_core.$_$.o1;
-  var KProperty1 = kotlin_kotlin.$_$.m8;
-  var getPropertyCallableRef = kotlin_kotlin.$_$.b7;
-  var sequenceOf = kotlin_kotlin.$_$.r9;
-  var flatMap = kotlin_kotlin.$_$.c9;
+  var KProperty1 = kotlin_kotlin.$_$.n8;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.c7;
+  var sequenceOf = kotlin_kotlin.$_$.s9;
+  var flatMap = kotlin_kotlin.$_$.d9;
   var Companion_getInstance_2 = kotlin_it_unibo_tuprolog_core.$_$.u;
   var Companion_getInstance_3 = kotlin_it_unibo_tuprolog_core.$_$.b1;
   var Companion_getInstance_4 = kotlin_it_unibo_tuprolog_core.$_$.z;
   var Companion_instance_4 = kotlin_it_unibo_tuprolog_core.$_$.p;
-  var filter = kotlin_kotlin.$_$.z8;
-  var Sequence = kotlin_kotlin.$_$.o8;
-  var firstOrNull = kotlin_kotlin.$_$.a9;
+  var filter = kotlin_kotlin.$_$.a9;
+  var Sequence = kotlin_kotlin.$_$.p8;
+  var firstOrNull = kotlin_kotlin.$_$.b9;
   var Companion_getInstance_5 = kotlin_it_unibo_tuprolog_core.$_$.v;
   var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.t;
   var asSequence_0 = kotlin_kotlin.$_$.m2;
   var addAll = kotlin_kotlin.$_$.f2;
-  var toList = kotlin_kotlin.$_$.d5;
+  var toList = kotlin_kotlin.$_$.e5;
   var Struct = kotlin_it_unibo_tuprolog_core.$_$.b2;
-  var Companion_instance_5 = kotlin_it_unibo_tuprolog_solve.$_$.q;
-  var filterNot = kotlin_kotlin.$_$.y8;
+  var Companion_instance_5 = kotlin_it_unibo_tuprolog_solve.$_$.r;
+  var filterNot = kotlin_kotlin.$_$.z8;
   var Truth = kotlin_it_unibo_tuprolog_core.$_$.b3;
-  var lazy = kotlin_kotlin.$_$.mc;
-  var Companion_instance_6 = kotlin_it_unibo_tuprolog_solve.$_$.t;
+  var lazy = kotlin_kotlin.$_$.pc;
+  var Companion_instance_6 = kotlin_it_unibo_tuprolog_solve.$_$.u;
   var Expected_STREAM_PROPERTY_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.e;
   var Expected_WRITE_OPTION_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.g;
   var Expected_READ_OPTION_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.b;
@@ -141,44 +141,47 @@
   var VarFormat_UNDERSCORE_getInstance = kotlin_it_unibo_tuprolog_core.$_$.f;
   var Expected_SOURCE_SINK_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.c;
   var Expected_IO_MODE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.a;
-  var Companion_instance_8 = kotlin_it_unibo_tuprolog_solve.$_$.v;
+  var Companion_instance_8 = kotlin_it_unibo_tuprolog_solve.$_$.w;
   var Expected_STREAM_OR_ALIAS_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.d;
-  var Expected_IN_CHARACTER_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.k;
-  var Companion_instance_9 = kotlin_it_unibo_tuprolog_solve.$_$.y;
-  var Limit_CHARACTER_CODE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.h;
+  var Expected_IN_CHARACTER_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.l;
+  var Companion_instance_9 = kotlin_it_unibo_tuprolog_solve.$_$.z;
+  var Limit_CHARACTER_CODE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.i;
   var Companion_getInstance_6 = kotlin_it_unibo_tuprolog_core.$_$.o;
   var Integer = kotlin_it_unibo_tuprolog_core.$_$.v1;
   var KtMap = kotlin_kotlin.$_$.c2;
   var Expected_STREAM_TYPE_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.f;
   var format = kotlin_it_unibo_tuprolog_core.$_$.e3;
-  var charCodeAt = kotlin_kotlin.$_$.r6;
+  var charCodeAt = kotlin_kotlin.$_$.s6;
   var emptyList = kotlin_kotlin.$_$.e3;
   var get_lastIndex = kotlin_kotlin.$_$.r3;
-  var toList_0 = kotlin_kotlin.$_$.aa;
+  var toList_0 = kotlin_kotlin.$_$.ba;
   var last = kotlin_kotlin.$_$.t3;
-  var Companion_instance_10 = kotlin_it_unibo_tuprolog_solve.$_$.z;
+  var Companion_instance_10 = kotlin_it_unibo_tuprolog_solve.$_$.a1;
   var ParseException = kotlin_it_unibo_tuprolog_parser_core.$_$.a;
   var emptySet = kotlin_kotlin.$_$.g3;
-  var noWhenBranchMatchedException = kotlin_kotlin.$_$.nc;
-  var NonBacktrackable_1 = kotlin_it_unibo_tuprolog_solve.$_$.u2;
-  var NonBacktrackable_2 = kotlin_it_unibo_tuprolog_solve.$_$.s2;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.qc;
+  var ObjectType_SOURCE_SINK_getInstance = kotlin_it_unibo_tuprolog_solve.$_$.h;
+  var ExistenceError_init_$Create$ = kotlin_it_unibo_tuprolog_solve.$_$.b2;
+  var FileNotFoundException = kotlin_com_squareup_okio_okio.$_$.d;
+  var NonBacktrackable_1 = kotlin_it_unibo_tuprolog_solve.$_$.v2;
+  var NonBacktrackable_2 = kotlin_it_unibo_tuprolog_solve.$_$.t2;
   var Companion_instance_11 = kotlin_it_unibo_tuprolog_parser_theory.$_$.a;
   var Companion_instance_12 = kotlin_it_unibo_tuprolog_theory.$_$.b;
   var Companion_instance_13 = kotlin_it_unibo_tuprolog_theory.$_$.a;
-  var charSequenceLength = kotlin_kotlin.$_$.t6;
-  var titlecase = kotlin_kotlin.$_$.hb;
-  var isLowerCase = kotlin_kotlin.$_$.pa;
-  var substring = kotlin_kotlin.$_$.fb;
-  var BinaryRelation = kotlin_it_unibo_tuprolog_solve.$_$.p2;
-  var distinct = kotlin_kotlin.$_$.u8;
-  var removeSuffix = kotlin_kotlin.$_$.va;
-  var toIntOrNull = kotlin_kotlin.$_$.kb;
-  var removePrefix = kotlin_kotlin.$_$.ta;
+  var charSequenceLength = kotlin_kotlin.$_$.u6;
+  var titlecase = kotlin_kotlin.$_$.jb;
+  var isLowerCase = kotlin_kotlin.$_$.qa;
+  var substring = kotlin_kotlin.$_$.hb;
+  var BinaryRelation = kotlin_it_unibo_tuprolog_solve.$_$.r2;
+  var distinct = kotlin_kotlin.$_$.v8;
+  var removeSuffix = kotlin_kotlin.$_$.wa;
+  var toIntOrNull = kotlin_kotlin.$_$.mb;
+  var removePrefix = kotlin_kotlin.$_$.ua;
   var buffer = kotlin_com_squareup_okio_okio.$_$.g;
-  var addSuppressed = kotlin_kotlin.$_$.ic;
+  var addSuppressed = kotlin_kotlin.$_$.kc;
   var IOException = kotlin_com_squareup_okio_okio.$_$.f;
-  var getStringHashCode = kotlin_kotlin.$_$.c7;
-  var KProperty0 = kotlin_kotlin.$_$.l8;
+  var getStringHashCode = kotlin_kotlin.$_$.d7;
+  var KProperty0 = kotlin_kotlin.$_$.m8;
   var Info_getInstance = kotlin_it_unibo_tuprolog_core.$_$.d1;
   var Platform_BROWSER_getInstance = kotlin_it_unibo_tuprolog_core.$_$.g;
   var Companion_getInstance_7 = kotlin_com_squareup_okio_okio.$_$.a;
@@ -421,7 +424,7 @@
   function Iterator$hasNext$ref(p0) {
     return constructCallableReference(function () {
       return p0.hasNext_bitz1p_k$();
-    }, 0, 0, 119, 'hasNext', [p0]);
+    }, 0, 0, 113, 'hasNext', [p0]);
   }
   var properties_initialized_ChannelUtils_kt_an3chc;
   function _init_properties_ChannelUtils_kt__fqios2() {
@@ -434,7 +437,11 @@
   function IOLib() {
     IOLib_instance = this;
     AbstractLibrary.call(this);
+    this.help_1 = "`library('prolog.io')`\n\nProvides the ISO Prolog stream-based input/output predicates. Streams are opened on files or URLs via `open/3,4` and are denoted by aliases (e.g. `user_input`, `user_output`) or by `$stream(Direction, Id)` terms; `close/1`, `current_input/1`, `current_output/1`, `set_input/1`, `set_output/1`, `stream_property/2`, `at_end_of_stream/0,1` and `flush_output/1` manage them. Only text streams are supported, and writing is only possible to local files on the JVM.\n\nCharacter-level I/O is offered by `get_char/1,2`, `get_code/1,2`, `peek_char/1,2`, `peek_code/1,2`, `put_char/1,2`, `put_code/1,2` and `nl/1`, while term-level I/O is offered by `read/1,2`, `read_term/2,3`, `write/2`, `writeq/1,2`, `write_canonical/1,2` and `write_term/2,3`; the variants without a stream argument use the current input or output stream. The tuProlog-specific `consult/1` adds the clauses of a theory loaded from a file or URL to the knowledge base, whereas `set_theory/1` replaces the knowledge base with a theory given as source text.\n\nThe byte-oriented predicates (`get_byte/1,2`, `peek_byte/1,2`, `put_byte/1,2`), the character conversion predicates (`char_conversion/2`, `current_char_conversion/2`) and `close/2` are registered for ISO conformance, but are not supported: calling them always raises a system error.";
   }
+  protoOf(IOLib).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(IOLib).get_alias_iooo4n_k$ = function () {
     return 'prolog.io';
   };
@@ -467,7 +474,7 @@
   function Atom$Companion$of$ref(p0) {
     return constructCallableReference(function (p0_0) {
       return p0.of(p0_0);
-    }, 1, 0, 120, 'of', [p0]);
+    }, 1, 0, 114, 'of', [p0]);
   }
   var static_init_called;
   function static_init() {
@@ -770,7 +777,11 @@
   function AtEndOfStream0() {
     AtEndOfStream0_instance = this;
     Predicative.call(this, 'at_end_of_stream');
+    this.help_1 = '`at_end_of_stream`\n\nSucceeds iff the current input stream (standard input, unless changed via `set_input/1`) is closed or has no more characters to read, and fails otherwise. It is deterministic and raises no errors.\n\n**Examples**\n\n```prolog\n% with `foo.` still to be read from standard input\n?- at_end_of_stream.\nno.\n\n% once standard input has been exhausted\n?- at_end_of_stream.\nyes.\n```';
   }
+  protoOf(AtEndOfStream0).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(AtEndOfStream0).compute_yf4j3j_k$ = function (_this__u8e3s4) {
     // Inline function 'kotlin.let' call
     var it = IOPrimitiveUtils_getInstance().get_currentInputChannel_31908p_k$(_this__u8e3s4);
@@ -788,7 +799,11 @@
   function AtEndOfStream1() {
     AtEndOfStream1_instance = this;
     Predicative_0.call(this, 'at_end_of_stream');
+    this.help_1 = '`at_end_of_stream(+Stream)`\n\nSucceeds iff the input stream `Stream` is closed or has no more characters to read, and fails otherwise. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error.\n\n**Examples**\n\n```prolog\n?- at_end_of_stream(user_output).\nthrows error(domain_error(stream_type, user_output), _).\n\n?- at_end_of_stream(S).\nthrows error(instantiation_error, _).\n\n?- at_end_of_stream(no_such_stream).\nthrows error(existence_error(source_sink, no_such_stream), _).\n```';
   }
+  protoOf(AtEndOfStream1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(AtEndOfStream1).compute_2uabro_k$ = function (_this__u8e3s4, first) {
     // Inline function 'kotlin.let' call
     var it = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
@@ -806,7 +821,11 @@
   function CharConversion() {
     CharConversion_instance = this;
     NonBacktrackable.call(this, 'char_conversion');
+    this.help_1 = '`char_conversion(+InChar, +OutChar)`\n\nRegistered for ISO conformance only: the current implementation does not support a character conversion table, so every call raises a system error regardless of its arguments.\n\n**Examples**\n\n```prolog\n?- char_conversion(a, b).\nthrows error(system_error, _).\n```';
   }
+  protoOf(CharConversion).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(CharConversion).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -836,7 +855,11 @@
   function Close1() {
     Close1_instance = this;
     NonBacktrackable_0.call(this, 'close');
+    this.help_1 = '`close(+Stream)`\n\nCloses the stream `Stream`, given as an alias or a `$stream(Direction, Id)` term, and unregisters every alias it was reachable through, succeeding deterministically. It raises an instantiation error if `Stream` is unbound, an existence error if it does not denote an open stream, and a domain error (`stream_or_alias`) if it is a compound term other than a stream term. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- close(S).\nthrows error(instantiation_error, _).\n\n?- close(no_such_stream).\nthrows error(existence_error(source_sink, no_such_stream), _).\n\n?- close(foo(bar)).\nthrows error(domain_error(stream_or_alias, foo(bar)), _).\n```';
   }
+  protoOf(Close1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Close1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsChannel_ed79nb_k$(_this__u8e3s4, 0);
     try {
@@ -873,7 +896,11 @@
   function Close2() {
     Close2_instance = this;
     NonBacktrackable.call(this, 'close');
+    this.help_1 = '`close(+Stream, +Options)`\n\nRegistered for ISO conformance only: the current implementation does not support close options such as `force(true)`, so every call raises a system error regardless of its arguments; use `close/1` instead.\n\n**Examples**\n\n```prolog\n?- close(user_output, [force(true)]).\nthrows error(system_error, _).\n```';
   }
+  protoOf(Close2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Close2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -889,7 +916,11 @@
   function Consult() {
     Consult_instance = this;
     NonBacktrackable_0.call(this, 'consult');
+    this.help_1 = "`consult(+Source)`\n\nLoads the Prolog theory found at `Source`, an atom holding either a URL (e.g. `'https://example.com/theory.pl'`) or a plain absolute or relative file path, parsing it with the current operators. This tuProlog-specific predicate adds the loaded clauses to the knowledge base without removing any existing clause (so consulting the same source twice duplicates its clauses), with clauses of predicates declared dynamic going to the dynamic knowledge base and all others to the static one; operators and flags set by the theory's directives take effect as well. It raises an instantiation error if `Source` is unbound, a type error (`atom`) if it is not an atom, a type error (`url`) if it is not a valid URL or path, a system error if the resource cannot be read, and a syntax error if its content is not a well-formed theory.\n\n**Examples**\n\n```prolog\n% with /path/to/family.pl containing `parent(tom, bob).`\n?- consult('/path/to/family.pl'), parent(tom, X).\nX = bob.\n\n?- consult(F).\nthrows error(instantiation_error, _).\n\n?- consult(42).\nthrows error(type_error(atom, 42), _).\n\n?- consult('/no/such/theory.pl').\nthrows error(system_error, _).\n```";
   }
+  protoOf(Consult).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Consult).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     Companion_getInstance_1().ensuringArgumentIsInstantiated_dpjvac_k$(_this__u8e3s4, 0);
     Companion_getInstance_1().ensuringArgumentIsAtom_5kuj97_k$(_this__u8e3s4, 0);
@@ -924,7 +955,11 @@
   function CurrentCharConversion() {
     CurrentCharConversion_instance = this;
     NonBacktrackable.call(this, 'current_char_conversion');
+    this.help_1 = '`current_char_conversion(?InChar, ?OutChar)`\n\nRegistered for ISO conformance only: since character conversion is not supported (see `char_conversion/2`), the current implementation raises a system error on every call regardless of its arguments.\n\n**Examples**\n\n```prolog\n?- current_char_conversion(X, Y).\nthrows error(system_error, _).\n```';
   }
+  protoOf(CurrentCharConversion).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(CurrentCharConversion).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -940,7 +975,11 @@
   function CurrentInput() {
     CurrentInput_instance = this;
     NonBacktrackable_0.call(this, 'current_input');
+    this.help_1 = '`current_input(?Stream)`\n\nUnifies `Stream` with the `$stream(in, Id)` term of the current input stream (standard input, unless changed via `set_input/1`); if `Stream` is already a stream term, it succeeds iff that term denotes the current input stream. It is deterministic. It raises an existence error if `Stream` is a stream term denoting no open stream, and a domain error (`stream_or_alias`) if it is bound to anything else, aliases included.\n\n**Examples**\n\n```prolog\n?- current_input(S), stream_property(S, alias(user_input)).\nyes.\n\n?- current_input(user_input).\nthrows error(domain_error(stream_or_alias, user_input), _).\n```';
   }
+  protoOf(CurrentInput).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(CurrentInput).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrStream_l86imo_k$(_this__u8e3s4, 0);
     // Inline function 'kotlin.let' call
@@ -961,7 +1000,11 @@
   function CurrentOutput() {
     CurrentOutput_instance = this;
     NonBacktrackable_0.call(this, 'current_output');
+    this.help_1 = '`current_output(?Stream)`\n\nUnifies `Stream` with the `$stream(out, Id)` term of the current output stream (standard output, unless changed via `set_output/1`); if `Stream` is already a stream term, it succeeds iff that term denotes the current output stream. It is deterministic. It raises an existence error if `Stream` is a stream term denoting no open stream, and a domain error (`stream_or_alias`) if it is bound to anything else, aliases included.\n\n**Examples**\n\n```prolog\n?- current_output(S), stream_property(S, alias(user_output)).\nyes.\n\n?- current_output(S), write(S, hello).\n% prints: hello\nyes.\n\n?- current_output(user_output).\nthrows error(domain_error(stream_or_alias, user_output), _).\n```';
   }
+  protoOf(CurrentOutput).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(CurrentOutput).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrStream_l86imo_k$(_this__u8e3s4, 0);
     // Inline function 'kotlin.let' call
@@ -982,7 +1025,11 @@
   function FlushOutput() {
     FlushOutput_instance = this;
     NonBacktrackable_0.call(this, 'flush_output');
+    this.help_1 = '`flush_output(+Stream)`\n\nForces any buffered output of the output stream `Stream` to be written to its destination, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write(user_output, hello), flush_output(user_output).\n% prints: hello\nyes.\n\n?- flush_output(user_input).\nthrows error(domain_error(stream_type, user_input), _).\n```';
   }
+  protoOf(FlushOutput).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(FlushOutput).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     var tmp;
@@ -1013,7 +1060,11 @@
   function GetByte1() {
     GetByte1_instance = this;
     NonBacktrackable_0.call(this, 'get_byte');
+    this.help_1 = '`get_byte(?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `get_code/1` instead.\n\n**Examples**\n\n```prolog\n?- get_byte(B).\nthrows error(system_error, _).\n```';
   }
+  protoOf(GetByte1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(GetByte1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -1029,7 +1080,11 @@
   function GetByte2() {
     GetByte2_instance = this;
     NonBacktrackable.call(this, 'get_byte');
+    this.help_1 = '`get_byte(+Stream, ?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `get_code/2` instead.\n\n**Examples**\n\n```prolog\n?- get_byte(user_input, B).\nthrows error(system_error, _).\n```';
   }
+  protoOf(GetByte2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(GetByte2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -1045,7 +1100,11 @@
   function GetChar1() {
     GetChar1_instance = this;
     NonBacktrackable_0.call(this, 'get_char');
+    this.help_1 = '`get_char(?Char)`\n\nReads and consumes the next character from the current input stream (standard input, unless changed via `set_input/1`) and unifies it with `Char`, which becomes `end_of_file` at the end of the stream. It is deterministic. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_char(ab).\nthrows error(type_error(in_character, ab), _).\n\n?- get_char(1).\nthrows error(type_error(in_character, 1), _).\n```';
   }
+  protoOf(GetChar1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(GetChar1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrChar_zdzofu_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().readCharAndReply_szx3md_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentInputChannel_31908p_k$(_this__u8e3s4), first);
@@ -1062,7 +1121,11 @@
   function GetChar2() {
     GetChar2_instance = this;
     NonBacktrackable.call(this, 'get_char');
+    this.help_1 = '`get_char(+Stream, ?Char)`\n\nReads and consumes the next character from the input stream `Stream` and unifies it with `Char`, which becomes `end_of_file` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_char(user_input, ab).\nthrows error(type_error(in_character, ab), _).\n\n?- get_char(S, C).\nthrows error(instantiation_error, _).\n\n?- get_char(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
   }
+  protoOf(GetChar2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(GetChar2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrChar_zdzofu_k$(_this__u8e3s4, 1);
@@ -1080,7 +1143,11 @@
   function GetCode1() {
     GetCode1_instance = this;
     NonBacktrackable_0.call(this, 'get_code');
+    this.help_1 = '`get_code(?Code)`\n\nReads and consumes the next character from the current input stream (standard input, unless changed via `set_input/1`) and unifies its code with `Code`, which becomes `-1` at the end of the stream. It is deterministic. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_code(a).\nthrows error(type_error(integer, a), _).\n\n?- get_code(-2).\nthrows error(representation_error(character_code), _).\n```';
   }
+  protoOf(GetCode1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(GetCode1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrCharCode_tmh0sz_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().readCodeAndReply_m7r1zg_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentInputChannel_31908p_k$(_this__u8e3s4), first);
@@ -1097,7 +1164,11 @@
   function GetCode2() {
     GetCode2_instance = this;
     NonBacktrackable.call(this, 'get_code');
+    this.help_1 = '`get_code(+Stream, ?Code)`\n\nReads and consumes the next character from the input stream `Stream` and unifies its code with `Code`, which becomes `-1` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- get_code(user_input, a).\nthrows error(type_error(integer, a), _).\n\n?- get_code(S, C).\nthrows error(instantiation_error, _).\n\n?- get_code(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
   }
+  protoOf(GetCode2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(GetCode2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrCharCode_tmh0sz_k$(_this__u8e3s4, 1);
@@ -1119,7 +1190,7 @@
     return constructCallableReference(function (p0_0) {
       var tmp0 = p0;
       return alias(tmp0, p0_0);
-    }, 1, 0, 121, 'alias', [p0]);
+    }, 1, 0, 115, 'alias', [p0]);
   }
   function IOPrimitiveUtils$propertiesOf$slambda$lambda_0(it) {
     return it === '$current';
@@ -1495,7 +1566,7 @@
   function IOPrimitiveUtils$_get_INPUT_STREAM_TERM_PATTERN_$ref_59oxnp() {
     return constructCallableReference(function (p0) {
       return _get_INPUT_STREAM_TERM_PATTERN__5fd8p6(p0);
-    }, 1, 0, 122);
+    }, 1, 0, 116);
   }
   function IOPrimitiveUtils$OUTPUT_STREAM_TERM_PATTERN$delegate$lambda() {
     return Companion_instance_5.streamTerm();
@@ -1503,7 +1574,7 @@
   function IOPrimitiveUtils$_get_OUTPUT_STREAM_TERM_PATTERN_$ref_kcdkmo() {
     return constructCallableReference(function (p0) {
       return _get_OUTPUT_STREAM_TERM_PATTERN__4vocxf(p0);
-    }, 1, 0, 123);
+    }, 1, 0, 117);
   }
   function IOPrimitiveUtils$PROPERTY_TYPE_PATTERN$delegate$lambda() {
     return Companion_getInstance_2().of('type', [Companion_getInstance_3().anonymous()]);
@@ -1511,7 +1582,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_TYPE_PATTERN_$ref_qcyh3d() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_TYPE_PATTERN__5nq864(p0);
-    }, 1, 0, 124);
+    }, 1, 0, 118);
   }
   function IOPrimitiveUtils$PROPERTY_REPOSITION_PATTERN$delegate$lambda() {
     return Companion_getInstance_2().of('reposition', [Companion_getInstance_3().anonymous()]);
@@ -1519,7 +1590,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_REPOSITION_PATTERN_$ref_uil93p() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_REPOSITION_PATTERN__lznuii(p0);
-    }, 1, 0, 125);
+    }, 1, 0, 119);
   }
   function IOPrimitiveUtils$PROPERTY_EOF_ACTION_PATTERN$delegate$lambda() {
     return Companion_getInstance_2().of('eof_action', [Companion_getInstance_3().anonymous()]);
@@ -1527,7 +1598,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_EOF_ACTION_PATTERN_$ref_bt8ai0() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_EOF_ACTION_PATTERN__8k2shv(p0);
-    }, 1, 0, 126);
+    }, 1, 0, 120);
   }
   function IOPrimitiveUtils$PROPERTY_ALIAS_PATTERN$delegate$lambda() {
     return alias(IOPrimitiveUtils_getInstance());
@@ -1535,7 +1606,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_ALIAS_PATTERN_$ref_qs5lfb() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_ALIAS_PATTERN__wipd2s(p0);
-    }, 1, 0, 127);
+    }, 1, 0, 121);
   }
   function IOPrimitiveUtils$PROPERTY_INPUT$delegate$lambda() {
     return Companion_getInstance_0().of('input');
@@ -1543,7 +1614,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_INPUT_$ref_hltzoy() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_INPUT__z2zr91(p0);
-    }, 1, 0, 128);
+    }, 1, 0, 122);
   }
   function IOPrimitiveUtils$PROPERTY_OUTPUT$delegate$lambda() {
     return Companion_getInstance_0().of('output');
@@ -1551,7 +1622,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_OUTPUT_$ref_9ccgyp() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_OUTPUT__1pem9m(p0);
-    }, 1, 0, 129);
+    }, 1, 0, 123);
   }
   function IOPrimitiveUtils$PROPERTY_TYPE_TEXT$delegate$lambda() {
     return Companion_getInstance_2().of('type', [Companion_getInstance_0().of('text')]);
@@ -1559,7 +1630,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_TYPE_TEXT_$ref_47hbty() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_TYPE_TEXT__9rpcwt(p0);
-    }, 1, 0, 130);
+    }, 1, 0, 124);
   }
   function IOPrimitiveUtils$PROPERTY_REPOSITION_FALSE$delegate$lambda() {
     return Companion_getInstance_2().of('reposition', [Companion_getInstance_4().FALSE_1]);
@@ -1567,7 +1638,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_REPOSITION_FALSE_$ref_jx0m6() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_REPOSITION_FALSE__i73t3b(p0);
-    }, 1, 0, 131);
+    }, 1, 0, 125);
   }
   function IOPrimitiveUtils$PROPERTY_EOF_ACTION_EOF_CODE$delegate$lambda() {
     return Companion_getInstance_2().of('eof_action', [Companion_getInstance_0().of('eof_code')]);
@@ -1575,7 +1646,7 @@
   function IOPrimitiveUtils$_get_PROPERTY_EOF_ACTION_EOF_CODE_$ref_1cwy66() {
     return constructCallableReference(function (p0) {
       return _get_PROPERTY_EOF_ACTION_EOF_CODE__he3pvl(p0);
-    }, 1, 0, 132);
+    }, 1, 0, 126);
   }
   function IOPrimitiveUtils$OPTION_QUOTED_PATTERN$delegate$lambda() {
     return quoted(IOPrimitiveUtils_getInstance());
@@ -1583,7 +1654,7 @@
   function IOPrimitiveUtils$_get_OPTION_QUOTED_PATTERN_$ref_nxjfbr() {
     return constructCallableReference(function (p0) {
       return _get_OPTION_QUOTED_PATTERN__n2ri42(p0);
-    }, 1, 0, 133);
+    }, 1, 0, 127);
   }
   function IOPrimitiveUtils$OPTION_NUMBER_VARS_PATTERN$delegate$lambda() {
     return numberVars(IOPrimitiveUtils_getInstance());
@@ -1591,7 +1662,7 @@
   function IOPrimitiveUtils$_get_OPTION_NUMBER_VARS_PATTERN_$ref_pdk9ph() {
     return constructCallableReference(function (p0) {
       return _get_OPTION_NUMBER_VARS_PATTERN__p98ste(p0);
-    }, 1, 0, 134);
+    }, 1, 0, 128);
   }
   function IOPrimitiveUtils$OPTION_IGNORE_OPS_PATTERN$delegate$lambda() {
     return ignoreOps(IOPrimitiveUtils_getInstance());
@@ -1599,7 +1670,7 @@
   function IOPrimitiveUtils$_get_OPTION_IGNORE_OPS_PATTERN_$ref_vvsa9g() {
     return constructCallableReference(function (p0) {
       return _get_OPTION_IGNORE_OPS_PATTERN__cpse4v(p0);
-    }, 1, 0, 135);
+    }, 1, 0, 129);
   }
   function IOPrimitiveUtils$INFO_VARIABLES_PATTERN$delegate$lambda() {
     return variables(IOPrimitiveUtils_getInstance());
@@ -1607,7 +1678,7 @@
   function IOPrimitiveUtils$_get_INFO_VARIABLES_PATTERN_$ref_ih2rd5() {
     return constructCallableReference(function (p0) {
       return _get_INFO_VARIABLES_PATTERN__bhp1h0(p0);
-    }, 1, 0, 136);
+    }, 1, 0, 130);
   }
   function IOPrimitiveUtils$INFO_VARIABLE_NAMES_PATTERN$delegate$lambda() {
     return variableNames(IOPrimitiveUtils_getInstance());
@@ -1615,7 +1686,7 @@
   function IOPrimitiveUtils$_get_INFO_VARIABLE_NAMES_PATTERN_$ref_lzmk91() {
     return constructCallableReference(function (p0) {
       return _get_INFO_VARIABLE_NAMES_PATTERN__j3oaom(p0);
-    }, 1, 0, 137);
+    }, 1, 0, 131);
   }
   function IOPrimitiveUtils$INFO_SINGLETONS_PATTERN$delegate$lambda() {
     return singletons(IOPrimitiveUtils_getInstance());
@@ -1623,25 +1694,25 @@
   function IOPrimitiveUtils$_get_INFO_SINGLETONS_PATTERN_$ref_8msi4i() {
     return constructCallableReference(function (p0) {
       return _get_INFO_SINGLETONS_PATTERN__y21s87(p0);
-    }, 1, 0, 138);
+    }, 1, 0, 132);
   }
   function IOPrimitiveUtils$quoted$ref(p0) {
     return constructCallableReference(function (p0_0) {
       var tmp0 = p0;
       return quoted(tmp0, p0_0);
-    }, 1, 0, 139, 'quoted', [p0]);
+    }, 1, 0, 133, 'quoted', [p0]);
   }
   function IOPrimitiveUtils$ignoreOps$ref(p0) {
     return constructCallableReference(function (p0_0) {
       var tmp0 = p0;
       return ignoreOps(tmp0, p0_0);
-    }, 1, 0, 140, 'ignoreOps', [p0]);
+    }, 1, 0, 134, 'ignoreOps', [p0]);
   }
   function IOPrimitiveUtils$numberVars$ref(p0) {
     return constructCallableReference(function (p0_0) {
       var tmp0 = p0;
       return numberVars(tmp0, p0_0);
-    }, 1, 0, 141, 'numberVars', [p0]);
+    }, 1, 0, 135, 'numberVars', [p0]);
   }
   function IOPrimitiveUtils$_get_validOptionsPattern_$lambda_r088xw(it) {
     return map(sequenceOf([true, false]), it);
@@ -2443,19 +2514,38 @@
     var tmp0_safe_receiver = tmp$ret$0;
     var alias = tmp0_safe_receiver == null ? null : _get_alias__jw26bj(this, tmp0_safe_receiver);
     var tmp_3;
-    switch (mode.ordinal_1) {
-      case 0:
-        tmp_3 = replyOpeningStream_0(this, _this__u8e3s4, openInputChannel(url), third, alias);
-        break;
-      case 1:
-        tmp_3 = replyOpeningStream(this, _this__u8e3s4, openOutputChannel(url, false), third, alias);
-        break;
-      case 2:
-        tmp_3 = replyOpeningStream(this, _this__u8e3s4, openOutputChannel(url, true), third, alias);
-        break;
-      default:
-        noWhenBranchMatchedException();
-        break;
+    try {
+      var tmp_4;
+      switch (mode.ordinal_1) {
+        case 0:
+          tmp_4 = replyOpeningStream_0(this, _this__u8e3s4, openInputChannel(url), third, alias);
+          break;
+        case 1:
+          tmp_4 = replyOpeningStream(this, _this__u8e3s4, openOutputChannel(url, false), third, alias);
+          break;
+        case 2:
+          tmp_4 = replyOpeningStream(this, _this__u8e3s4, openOutputChannel(url, true), third, alias);
+          break;
+        default:
+          noWhenBranchMatchedException();
+          break;
+      }
+      tmp_3 = tmp_4;
+    } catch ($p) {
+      var tmp_5;
+      if ($p instanceof IOException_0) {
+        var e = $p;
+        var tmp_6;
+        var tmp_7 = e.cause;
+        if (tmp_7 instanceof FileNotFoundException) {
+          tmp_6 = ExistenceError_init_$Create$(e.message, e, _this__u8e3s4.context, ObjectType_SOURCE_SINK_getInstance(), _this__u8e3s4.arguments.get_c1px32_k$(0));
+        } else {
+          tmp_6 = e.toLogicError_33irru_k$(_this__u8e3s4.context);
+        }
+        throw tmp_6;
+      } else {
+        throw $p;
+      }
     }
     return tmp_3;
   };
@@ -2468,7 +2558,11 @@
   function Nl1() {
     Nl1_instance = this;
     NonBacktrackable_0.call(this, 'nl');
+    this.help_1 = '`nl(+Stream)`\n\nWrites a newline character to the output stream `Stream`, succeeding deterministically (`nl/0`, writing to the current output, is provided by `prolog.lang`). `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write(user_output, hello), nl(user_output).\n% prints: hello, then a newline\nyes.\n\n?- nl(user_input).\nthrows error(domain_error(stream_type, user_input), _).\n\n?- nl(S).\nthrows error(instantiation_error, _).\n```';
   }
+  protoOf(Nl1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Nl1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     var tmp;
@@ -2499,7 +2593,11 @@
   function Open3() {
     Open3_instance = this;
     NonBacktrackable_1.call(this, 'open');
+    this.help_1 = "`open(+SourceSink, +Mode, -Stream)`\n\nOpens `SourceSink`, an atom holding a URL or a plain file path, in `Mode` (`read`, `write` or `append`), registers the new stream under an auto-generated alias, and unifies `Stream` with its `$stream(Direction, Id)` term; it behaves as `open/4` with an empty options list. Any URL readable by the platform (e.g. files or `http(s)`) can be opened for reading, but the current implementation can only write or append to local files on the JVM, and never on JS. It raises an instantiation error if `SourceSink` or `Mode` is unbound, a domain error (`source_sink`) if `SourceSink` is not a valid URL or path, a type or domain error (`io_mode`) if `Mode` is not one of the allowed atoms, a type error (`variable`) if `Stream` is bound (ISO prescribes an uninstantiation error), an existence error (`source_sink`) if the resource does not exist, and a system error if it cannot be opened for any other reason.\n\n**Examples**\n\n```prolog\n% with /path/to/data.pl containing `hello(world).`\n?- open('/path/to/data.pl', read, S), read(S, T), close(S).\nT = hello(world).\n\n?- open(F, read, S).\nthrows error(instantiation_error, _).\n\n?- open('/path/to/data.pl', update, S).\nthrows error(domain_error(io_mode, update), _).\n\n?- open('/path/to/data.pl', read, foo).\nthrows error(type_error(variable, foo), _).\n```";
   }
+  protoOf(Open3).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Open3).computeOne_oq9h0q_k$ = function (_this__u8e3s4, first, second, third) {
     return IOPrimitiveUtils_getInstance().open_28mql5_k$(_this__u8e3s4, third);
   };
@@ -2515,7 +2613,11 @@
   function Open4() {
     Open4_instance = this;
     NonBacktrackable_2.call(this, 'open');
+    this.help_1 = "`open(+SourceSink, +Mode, -Stream, +Options)`\n\nLike `open/3`, opens `SourceSink` (a URL or file path atom) in `Mode` (`read`, `write` or `append`) and unifies `Stream` with the new `$stream(Direction, Id)` term, but also takes a list of `Options`. In the current implementation only `alias(Name)` has an effect, registering the stream under `Name` instead of an auto-generated alias; `input`, `output`, `type(text)`, `eof_action(eof_code)` and `reposition(false)` are accepted and ignored, other values of `type/1`, `eof_action/1` and `reposition/1` (e.g. `type(binary)`) raise a system error, and any other element raises a domain error (`stream_property`). `Options` must be a list (type error otherwise, even when unbound), and all other arguments are checked and raise errors exactly as for `open/3`.\n\n**Examples**\n\n```prolog\n?- open('/path/to/out.txt', write, _, [alias(out)]), write(out, hello), close(out).\nyes.\n\n?- open('/path/to/out.txt', write, S, [type(binary)]).\nthrows error(system_error, _).\n\n?- open('/path/to/out.txt', write, S, [foo]).\nthrows error(domain_error(stream_property, foo), _).\n```";
   }
+  protoOf(Open4).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Open4).computeOne_q4u7r9_k$ = function (_this__u8e3s4, first, second, third, fourth) {
     return IOPrimitiveUtils_getInstance().open_28mql5_k$(_this__u8e3s4, third);
   };
@@ -2531,7 +2633,11 @@
   function PeekByte1() {
     PeekByte1_instance = this;
     NonBacktrackable_0.call(this, 'peek_byte');
+    this.help_1 = '`peek_byte(?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `peek_code/1` instead.\n\n**Examples**\n\n```prolog\n?- peek_byte(B).\nthrows error(system_error, _).\n```';
   }
+  protoOf(PeekByte1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PeekByte1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -2547,7 +2653,11 @@
   function PeekByte2() {
     PeekByte2_instance = this;
     NonBacktrackable.call(this, 'peek_byte');
+    this.help_1 = '`peek_byte(+Stream, ?Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `peek_code/2` instead.\n\n**Examples**\n\n```prolog\n?- peek_byte(user_input, B).\nthrows error(system_error, _).\n```';
   }
+  protoOf(PeekByte2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PeekByte2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -2563,7 +2673,11 @@
   function PeekChar1() {
     PeekChar1_instance = this;
     NonBacktrackable_0.call(this, 'peek_char');
+    this.help_1 = '`peek_char(?Char)`\n\nUnifies `Char` with the next character of the current input stream (standard input, unless changed via `set_input/1`) without consuming it, or with `end_of_file` at the end of the stream. It is deterministic. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_char(ab).\nthrows error(type_error(in_character, ab), _).\n```';
   }
+  protoOf(PeekChar1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PeekChar1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrChar_zdzofu_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().peekCharAndReply_r80pc6_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentInputChannel_31908p_k$(_this__u8e3s4), first);
@@ -2580,7 +2694,11 @@
   function PeekChar2() {
     PeekChar2_instance = this;
     NonBacktrackable.call(this, 'peek_char');
+    this.help_1 = '`peek_char(+Stream, ?Char)`\n\nUnifies `Char` with the next character of the input stream `Stream` without consuming it, or with `end_of_file` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Char` must be unbound, `end_of_file`, or a one-character atom, otherwise a type error (`in_character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_char(user_input, ab).\nthrows error(type_error(in_character, ab), _).\n\n?- peek_char(S, C).\nthrows error(instantiation_error, _).\n\n?- peek_char(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
   }
+  protoOf(PeekChar2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PeekChar2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrChar_zdzofu_k$(_this__u8e3s4, 1);
@@ -2598,7 +2716,11 @@
   function PeekCode1() {
     PeekCode1_instance = this;
     NonBacktrackable_0.call(this, 'peek_code');
+    this.help_1 = '`peek_code(?Code)`\n\nUnifies `Code` with the code of the next character of the current input stream (standard input, unless changed via `set_input/1`) without consuming it, or with `-1` at the end of the stream. It is deterministic. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_code(a).\nthrows error(type_error(integer, a), _).\n\n?- peek_code(-2).\nthrows error(representation_error(character_code), _).\n```';
   }
+  protoOf(PeekCode1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PeekCode1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrCharCode_tmh0sz_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().peekCodeAndReply_y06qz3_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentInputChannel_31908p_k$(_this__u8e3s4), first);
@@ -2615,7 +2737,11 @@
   function PeekCode2() {
     PeekCode2_instance = this;
     NonBacktrackable.call(this, 'peek_code');
+    this.help_1 = '`peek_code(+Stream, ?Code)`\n\nUnifies `Code` with the code of the next character of the input stream `Stream` without consuming it, or with `-1` at the end of the stream. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. `Code` must be unbound or an integer (type error otherwise) within the character-code range or `-1` (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- peek_code(user_input, a).\nthrows error(type_error(integer, a), _).\n\n?- peek_code(S, C).\nthrows error(instantiation_error, _).\n\n?- peek_code(user_output, C).\nthrows error(domain_error(stream_type, user_output), _).\n```';
   }
+  protoOf(PeekCode2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PeekCode2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrCharCode_tmh0sz_k$(_this__u8e3s4, 1);
@@ -2633,7 +2759,11 @@
   function PutByte1() {
     PutByte1_instance = this;
     NonBacktrackable_0.call(this, 'put_byte');
+    this.help_1 = '`put_byte(+Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `put_code/1` instead.\n\n**Examples**\n\n```prolog\n?- put_byte(65).\nthrows error(system_error, _).\n```';
   }
+  protoOf(PutByte1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PutByte1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -2649,7 +2779,11 @@
   function PutByte2() {
     PutByte2_instance = this;
     NonBacktrackable.call(this, 'put_byte');
+    this.help_1 = '`put_byte(+Stream, +Byte)`\n\nRegistered for ISO conformance only: the current implementation supports text streams exclusively, so every call raises a system error regardless of its arguments; use `put_code/2` instead.\n\n**Examples**\n\n```prolog\n?- put_byte(user_output, 65).\nthrows error(system_error, _).\n```';
   }
+  protoOf(PutByte2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PutByte2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     return Companion_getInstance_1().notSupported$default_bmg7vb_k$(_this__u8e3s4);
   };
@@ -2665,7 +2799,11 @@
   function PutChar1() {
     PutChar1_instance = this;
     NonBacktrackable_0.call(this, 'put_char');
+    this.help_1 = '`put_char(+Char)`\n\nWrites the character `Char` to the current output stream (standard output, unless changed via `set_output/1`), succeeding deterministically. `Char` must be a one-character atom, otherwise a type error (`character`) is raised; the current implementation raises that type error even when `Char` is unbound, where ISO prescribes an instantiation error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_char(a).\n% prints: a\nyes.\n\n?- put_char(ab).\nthrows error(type_error(character, ab), _).\n\n?- put_char(C).\nthrows error(type_error(character, _), _).\n```';
   }
+  protoOf(PutChar1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PutChar1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     Companion_getInstance_1().ensuringArgumentIsChar_t2ym2o_k$(_this__u8e3s4, 0);
     var tmp = IOPrimitiveUtils_getInstance();
@@ -2684,7 +2822,11 @@
   function PutChar2() {
     PutChar2_instance = this;
     NonBacktrackable.call(this, 'put_char');
+    this.help_1 = '`put_char(+Stream, +Char)`\n\nWrites the character `Char` to the output stream `Stream`, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. `Char` must be a one-character atom, otherwise (even when unbound) a type error (`character`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_char(user_output, a).\n% prints: a\nyes.\n\n?- put_char(user_output, ab).\nthrows error(type_error(character, ab), _).\n\n?- put_char(user_input, a).\nthrows error(domain_error(stream_type, user_input), _).\n```';
   }
+  protoOf(PutChar2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PutChar2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     Companion_getInstance_1().ensuringArgumentIsChar_t2ym2o_k$(_this__u8e3s4, 1);
@@ -2703,7 +2845,11 @@
   function PutCode1() {
     PutCode1_instance = this;
     NonBacktrackable_0.call(this, 'put_code');
+    this.help_1 = '`put_code(+Code)`\n\nWrites the character whose code is `Code` to the current output stream (standard output, unless changed via `set_output/1`), succeeding deterministically. `Code` must be an integer, otherwise (even when unbound, where ISO prescribes an instantiation error) a type error (`integer`) is raised, and a valid character code, otherwise a representation error (`character_code`) is raised. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_code(97).\n% prints: a\nyes.\n\n?- put_code(a).\nthrows error(type_error(integer, a), _).\n\n?- put_code(-1).\nthrows error(representation_error(character_code), _).\n```';
   }
+  protoOf(PutCode1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PutCode1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     Companion_getInstance_1().ensuringArgumentIsCharCode_64rreb_k$(_this__u8e3s4, 0);
     var tmp = IOPrimitiveUtils_getInstance();
@@ -2722,7 +2868,11 @@
   function PutCode2() {
     PutCode2_instance = this;
     NonBacktrackable.call(this, 'put_code');
+    this.help_1 = '`put_code(+Stream, +Code)`\n\nWrites the character whose code is `Code` to the output stream `Stream`, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. `Code` must be an integer (type error otherwise, even when unbound) and a valid character code (representation error otherwise). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- put_code(user_output, 97).\n% prints: a\nyes.\n\n?- put_code(user_output, C).\nthrows error(type_error(integer, _), _).\n\n?- put_code(user_input, 97).\nthrows error(domain_error(stream_type, user_input), _).\n```';
   }
+  protoOf(PutCode2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(PutCode2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     Companion_getInstance_1().ensuringArgumentIsCharCode_64rreb_k$(_this__u8e3s4, 1);
@@ -2741,7 +2891,11 @@
   function Read1() {
     Read1_instance = this;
     NonBacktrackable_0.call(this, 'read');
+    this.help_1 = '`read(?Term)`\n\nReads the next term, terminated by a full stop, from the current input stream (standard input, unless changed via `set_input/1`) and unifies it with `Term`, using the current operators. It is deterministic. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n% with `foo(X, bar).` to be read from standard input\n?- read(T).\nT = foo(_, bar).\n\n% once standard input has been exhausted\n?- read(T).\nno.\n```';
   }
+  protoOf(Read1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Read1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     return IOPrimitiveUtils_getInstance().readTermAndReply$default_yi3mi7_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentInputChannel_31908p_k$(_this__u8e3s4), first);
   };
@@ -2757,7 +2911,11 @@
   function Read2() {
     Read2_instance = this;
     NonBacktrackable.call(this, 'read');
+    this.help_1 = '`read(+Stream, ?Term)`\n\nReads the next term, terminated by a full stop, from the input stream `Stream` and unifies it with `Term`, using the current operators. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n?- read(S, T).\nthrows error(instantiation_error, _).\n\n?- read(user_output, T).\nthrows error(domain_error(stream_type, user_output), _).\n\n?- read(no_such_stream, T).\nthrows error(existence_error(source_sink, no_such_stream), _).\n```';
   }
+  protoOf(Read2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Read2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().readTermAndReply$default_yi3mi7_k$(_this__u8e3s4, channel, second);
@@ -2774,7 +2932,11 @@
   function ReadTerm2() {
     ReadTerm2_instance = this;
     NonBacktrackable.call(this, 'read_term');
+    this.help_1 = "`read_term(?Term, ?Options)`\n\nReads the next term from the current input stream (standard input, unless changed via `set_input/1`) like `read/1`, and unifies the elements of the `Options` list with information about the term's variables. Each element of `Options` may be `variables(Vars)` (the variables of the term, in order of appearance), `variable_names(Names)` (a list of `'Name' = Var` pairs) or `singletons(Names)` (the same, for variables occurring once); other elements raise a domain error (`read_option`). Deviating from ISO, an unbound `Options` is not an error: it is unified with `[variables(Vars), variable_names(Names), singletons(Singletons)]`. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n?- read_term(T, [foo]).\nthrows error(domain_error(read_option, foo), _).\n\n?- read_term(T, foo).\nthrows error(type_error(list, foo), _).\n```";
   }
+  protoOf(ReadTerm2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(ReadTerm2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     return IOPrimitiveUtils_getInstance().readTermAndReply_11biz4_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentInputChannel_31908p_k$(_this__u8e3s4), first, true);
   };
@@ -2790,7 +2952,11 @@
   function ReadTerm3() {
     ReadTerm3_instance = this;
     NonBacktrackable_1.call(this, 'read_term');
+    this.help_1 = "`read_term(+Stream, ?Term, ?Options)`\n\nReads the next term from the input stream `Stream` like `read/2`, and unifies the elements of the `Options` list with information about the term's variables. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error. Each element of `Options` may be `variables(Vars)` (the variables of the term, in order of appearance), `variable_names(Names)` (a list of `'Name' = Var` pairs) or `singletons(Names)` (the same, for variables occurring once); other elements raise a domain error (`read_option`). Deviating from ISO, an unbound `Options` is not an error: it is unified with `[variables(Vars), variable_names(Names), singletons(Singletons)]`. Deviating from ISO, the current implementation fails, instead of unifying `Term` with `end_of_file`, when no more terms are available; it raises a syntax error if the next term is malformed and a system error if the channel is closed or cannot be read term by term.\n\n**Examples**\n\n```prolog\n?- read_term(user_input, T, [foo]).\nthrows error(domain_error(read_option, foo), _).\n\n?- read_term(S, T, []).\nthrows error(instantiation_error, _).\n\n?- read_term(user_output, T, []).\nthrows error(domain_error(stream_type, user_output), _).\n```";
   }
+  protoOf(ReadTerm3).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(ReadTerm3).computeOne_oq9h0q_k$ = function (_this__u8e3s4, first, second, third) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().readTermAndReply_11biz4_k$(_this__u8e3s4, channel, second, true);
@@ -2813,7 +2979,11 @@
   function SetInput() {
     SetInput_instance = this;
     NonBacktrackable_0.call(this, 'set_input');
+    this.help_1 = '`set_input(+Stream)`\n\nMakes the input stream `Stream` the current input stream, i.e. the one used by the predicates without an explicit stream argument (e.g. `get_char/1`, `read/1`), succeeding deterministically. `Stream` must be an alias (e.g. `user_input`) or a `$stream(in, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an output stream a domain error (`stream_type`), where ISO prescribes a permission error.\n\n**Examples**\n\n```prolog\n?- set_input(user_input), current_input(S), stream_property(S, alias(user_input)).\nyes.\n\n?- set_input(user_output).\nthrows error(domain_error(stream_type, user_output), _).\n\n?- set_input(S).\nthrows error(instantiation_error, _).\n```';
   }
+  protoOf(SetInput).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(SetInput).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsInputChannel_w9cvb1_k$(_this__u8e3s4, 0);
     return _this__u8e3s4.replySuccessBuildingSideEffects(VOID, VOID, SetInput$computeOne$lambda(_this__u8e3s4, channel));
@@ -2836,7 +3006,11 @@
   function SetOutput() {
     SetOutput_instance = this;
     NonBacktrackable_0.call(this, 'set_output');
+    this.help_1 = '`set_output(+Stream)`\n\nMakes the output stream `Stream` the current output stream, i.e. the one used by the predicates without an explicit stream argument (e.g. `put_char/1`, `write/1`), succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error.\n\n**Examples**\n\n```prolog\n?- set_output(user_output), put_char(a).\n% prints: a\nyes.\n\n?- set_output(user_input).\nthrows error(domain_error(stream_type, user_input), _).\n\n?- set_output(S).\nthrows error(instantiation_error, _).\n```';
   }
+  protoOf(SetOutput).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(SetOutput).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     return _this__u8e3s4.replySuccessBuildingSideEffects(VOID, VOID, SetOutput$computeOne$lambda(_this__u8e3s4, channel));
@@ -2867,7 +3041,11 @@
   function SetTheory() {
     SetTheory_instance = this;
     NonBacktrackable_0.call(this, 'set_theory');
+    this.help_1 = "`set_theory(+Text)`\n\nParses the atom `Text` as Prolog source code, using the current operators, and makes the resulting theory the new knowledge base: both the static and the dynamic knowledge bases are replaced (clauses of predicates declared dynamic go to the dynamic one), and operators and flags set by its directives take effect. This predicate is tuProlog-specific; see `consult/1` to add clauses loaded from a file or URL instead. It raises a type error (`atom`) if `Text` is not an atom (including when it is unbound, where an instantiation error would be customary) and a syntax error if `Text` is not a well-formed theory.\n\n**Examples**\n\n```prolog\n?- set_theory('parent(tom, bob). parent(bob, ann).'), parent(bob, X).\nX = ann.\n\n?- set_theory(42).\nthrows error(type_error(atom, 42), _).\n\n?- set_theory('foo(.').\nthrows error(syntax_error, _).\n```";
   }
+  protoOf(SetTheory).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(SetTheory).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     Companion_getInstance_1().ensuringArgumentIsAtom_5kuj97_k$(_this__u8e3s4, 0);
     return this.setTheory_ratc22_k$(_this__u8e3s4, first.castTo_8vzplt_k$().get_value_j01efc_k$(), false);
@@ -2958,7 +3136,11 @@
   function StreamProperty() {
     StreamProperty_instance = this;
     BinaryRelation.call(this, 'stream_property');
+    this.help_1 = '`stream_property(?Stream, ?Property)`\n\nEnumerates, on backtracking, every open stream `Stream` (as a `$stream(Direction, Id)` term) together with each `Property` holding for it; the current implementation reports `input` or `output`, one `alias(Name)` per alias of the stream, and `type(text)`. If `Stream` is bound it must be a stream term (aliases are not accepted), otherwise a domain error (`stream_or_alias`) is raised, or an existence error if it denotes no open stream. If `Property` is bound it must be `input`, `output` or `alias(Name)`, otherwise a domain error (`stream_property`) is raised, so the reported `type(text)` property cannot be queried directly.\n\n**Examples**\n\n```prolog\n?- stream_property(S, alias(user_output)), stream_property(S, output).\nyes.\n\n?- stream_property(S, type(text)).\nthrows error(domain_error(stream_property, type(text)), _).\n\n?- stream_property(user_output, P).\nthrows error(domain_error(stream_or_alias, user_output), _).\n```';
   }
+  protoOf(StreamProperty).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(StreamProperty).computeAll_3ok8b8_k$ = function (_this__u8e3s4, first, second) {
     IOPrimitiveUtils_getInstance().ensuringArgumentIsVarOrStream_l86imo_k$(_this__u8e3s4, 0);
     IOPrimitiveUtils_getInstance().ensuringArgumentIsStreamProperty_6yg2an_k$(_this__u8e3s4, 1);
@@ -2982,7 +3164,11 @@
   function Write2() {
     Write2_instance = this;
     NonBacktrackable.call(this, 'write');
+    this.help_1 = "`write(+Stream, @Term)`\n\nWrites `Term` to the output stream `Stream` as `write/1` does: unquoted, using the current operators, and writing `'$VAR'(N)` terms as variable letters. It succeeds deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write(user_output, 'hello world').\n% prints: hello world\nyes.\n\n?- write(user_output, f('A', 1 + 2, '$VAR'(27))).\n% prints: f(A, 1 + 2, B1)\nyes.\n\n?- write(user_input, hello).\nthrows error(domain_error(stream_type, user_input), _).\n```";
   }
+  protoOf(Write2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(Write2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().writeTermAndReply_wyva0k_k$(_this__u8e3s4, channel, second, Companion_instance_7.default(_this__u8e3s4.context.get_operators_z0nmfu_k$()));
@@ -2999,7 +3185,11 @@
   function WriteCanonical1() {
     WriteCanonical1_instance = this;
     NonBacktrackable_0.call(this, 'write_canonical');
+    this.help_1 = "`write_canonical(@Term)`\n\nWrites `Term` to the current output stream (standard output, unless changed via `set_output/1`) in canonical form: atoms and functors are quoted where needed, operators are written in functional notation, and `'$VAR'(N)` terms are written as-is. It succeeds deterministically. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_canonical(f('A', 1 + 2, '$VAR'(27))).\n% prints: f('A', '+'(1, 2), '$VAR'(27))\nyes.\n```";
   }
+  protoOf(WriteCanonical1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(WriteCanonical1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     return IOPrimitiveUtils_getInstance().writeTermAndReply_wyva0k_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentOutputChannel_jl8tcy_k$(_this__u8e3s4), first, Companion_instance_7.canonical());
   };
@@ -3015,7 +3205,11 @@
   function WriteCanonical2() {
     WriteCanonical2_instance = this;
     NonBacktrackable.call(this, 'write_canonical');
+    this.help_1 = "`write_canonical(+Stream, @Term)`\n\nWrites `Term` to the output stream `Stream` in canonical form: atoms and functors are quoted where needed, operators are written in functional notation, and `'$VAR'(N)` terms are written as-is. It succeeds deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_canonical(user_output, f('A', 1 + 2)).\n% prints: f('A', '+'(1, 2))\nyes.\n\n?- write_canonical(user_input, a).\nthrows error(domain_error(stream_type, user_input), _).\n```";
   }
+  protoOf(WriteCanonical2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(WriteCanonical2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().writeTermAndReply_wyva0k_k$(_this__u8e3s4, channel, second, Companion_instance_7.canonical());
@@ -3032,7 +3226,11 @@
   function WriteEq1() {
     WriteEq1_instance = this;
     NonBacktrackable_0.call(this, 'writeq');
+    this.help_1 = "`writeq(@Term)`\n\nWrites `Term` to the current output stream (standard output, unless changed via `set_output/1`) so that it can be read back: atoms and functors are quoted where needed, operators are written in operator notation, and `'$VAR'(N)` terms are written as variable letters. It succeeds deterministically. The current implementation formats operators according to the default operator table rather than the current one. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- writeq(f('A', 'hello world', 1 + 2, '$VAR'(27))).\n% prints: f('A', 'hello world', 1 + 2, B1)\nyes.\n```";
   }
+  protoOf(WriteEq1).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(WriteEq1).computeOne_6dkmes_k$ = function (_this__u8e3s4, first) {
     return IOPrimitiveUtils_getInstance().writeTermAndReply_wyva0k_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentOutputChannel_jl8tcy_k$(_this__u8e3s4), first, Companion_instance_7.readable());
   };
@@ -3048,7 +3246,11 @@
   function WriteEq2() {
     WriteEq2_instance = this;
     NonBacktrackable.call(this, 'writeq');
+    this.help_1 = "`writeq(+Stream, @Term)`\n\nWrites `Term` to the output stream `Stream` so that it can be read back, quoting atoms and functors where needed and writing `'$VAR'(N)` terms as variable letters; the current implementation formats operators according to the default operator table rather than the current one. It succeeds deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- writeq(user_output, f('A', 1 + 2)).\n% prints: f('A', 1 + 2)\nyes.\n\n?- writeq(user_input, a).\nthrows error(domain_error(stream_type, user_input), _).\n```";
   }
+  protoOf(WriteEq2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(WriteEq2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     return IOPrimitiveUtils_getInstance().writeTermAndReply_wyva0k_k$(_this__u8e3s4, channel, second, Companion_instance_7.readable());
@@ -3065,7 +3267,11 @@
   function WriteTerm2() {
     WriteTerm2_instance = this;
     NonBacktrackable.call(this, 'write_term');
+    this.help_1 = "`write_term(@Term, +Options)`\n\nWrites `Term` to the current output stream (standard output, unless changed via `set_output/1`), formatted according to `Options` and the current operators, succeeding deterministically. `Options` must be a list (an unbound `Options` raises a type error (`list`) rather than ISO's instantiation error) whose elements are `quoted(Bool)` (quote atoms and functors where needed), `ignore_ops(Bool)` (write operators in canonical functional notation) and `numbervars(Bool)` (write `'$VAR'(N)` terms as variable letters), with `Bool` being `true` or `false`; missing options default to `false`, and any other element raises a domain error (`write_option`). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_term(f('A', 1 + 2), [quoted(true), ignore_ops(true)]).\n% prints: f('A', '+'(1, 2))\nyes.\n\n?- write_term(f('A', 1 + 2), []).\n% prints: f(A, 1 + 2)\nyes.\n\n?- write_term(a, [foo]).\nthrows error(domain_error(write_option, foo), _).\n\n?- write_term(a, Options).\nthrows error(type_error(list, _), _).\n```";
   }
+  protoOf(WriteTerm2).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(WriteTerm2).computeOne_sdv9lb_k$ = function (_this__u8e3s4, first, second) {
     var formatter = IOPrimitiveUtils_getInstance().ensuringArgumentIsFormatter_5l8dg0_k$(_this__u8e3s4, 1);
     return IOPrimitiveUtils_getInstance().writeTermAndReply_wyva0k_k$(_this__u8e3s4, IOPrimitiveUtils_getInstance().get_currentOutputChannel_jl8tcy_k$(_this__u8e3s4), first, formatter);
@@ -3082,7 +3288,11 @@
   function WriteTerm3() {
     WriteTerm3_instance = this;
     NonBacktrackable_1.call(this, 'write_term');
+    this.help_1 = "`write_term(+Stream, @Term, +Options)`\n\nWrites `Term` to the output stream `Stream`, formatted according to `Options` and the current operators, succeeding deterministically. `Stream` must be an alias (e.g. `user_output`) or a `$stream(out, Id)` term denoting an open stream: an unbound `Stream` raises an instantiation error, an unknown one an existence error, and an input stream a domain error (`stream_type`), where ISO prescribes a permission error. `Options` must be a list (an unbound `Options` raises a type error (`list`) rather than ISO's instantiation error) whose elements are `quoted(Bool)` (quote atoms and functors where needed), `ignore_ops(Bool)` (write operators in canonical functional notation) and `numbervars(Bool)` (write `'$VAR'(N)` terms as variable letters), with `Bool` being `true` or `false`; missing options default to `false`, and any other element raises a domain error (`write_option`). It fails, instead of raising an error, if the underlying channel has been closed.\n\n**Examples**\n\n```prolog\n?- write_term(user_output, '$VAR'(27), [numbervars(true)]).\n% prints: B1\nyes.\n\n?- write_term(user_output, a, [quoted(maybe)]).\nthrows error(domain_error(write_option, quoted(maybe)), _).\n\n?- write_term(user_input, a, []).\nthrows error(domain_error(stream_type, user_input), _).\n```";
   }
+  protoOf(WriteTerm3).get_help_won7nu_k$ = function () {
+    return this.help_1;
+  };
   protoOf(WriteTerm3).computeOne_oq9h0q_k$ = function (_this__u8e3s4, first, second, third) {
     var channel = IOPrimitiveUtils_getInstance().ensuringArgumentIsOutputChannel_kmdrtk_k$(_this__u8e3s4, 0);
     var formatter = IOPrimitiveUtils_getInstance().ensuringArgumentIsFormatter_5l8dg0_k$(_this__u8e3s4, 2);
@@ -3359,7 +3569,7 @@
   function _get_REQUEST_$ref_g5y4c1() {
     return constructCallableReference(function () {
       return get_REQUEST();
-    }, 0, 0, 142);
+    }, 0, 0, 136);
   }
   var properties_initialized_RemoteAndBrowserIO_kt_w2uybl;
   function _init_properties_RemoteAndBrowserIO_kt__6j78jn() {
@@ -3459,7 +3669,7 @@
   function _get_FILE_URL_TO_PATH_$ref_kwvzgc() {
     return constructCallableReference(function () {
       return get_FILE_URL_TO_PATH();
-    }, 0, 0, 143);
+    }, 0, 0, 137);
   }
   function openInputChannel$lambda($this_openInputChannel) {
     return function () {