@pod-os/core 0.6.1-2196a40.0 → 0.6.1-4ea2c6e.0

package/lib/index.js

@@ -25,6 +25,10 @@ var PodOS = (() => {
     return to;
   };
   var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
     isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
     mod
   ));
@@ -1011,6 +1015,9 @@ var PodOS = (() => {
   var init_errors = __esm({
     "../node_modules/jose/dist/browser/util/errors.js"() {
       JOSEError = class extends Error {
+        static get code() {
+          return "ERR_JOSE_GENERIC";
+        }
         constructor(message2) {
           var _a;
           super(message2);
@@ -1018,31 +1025,28 @@ var PodOS = (() => {
           this.name = this.constructor.name;
           (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
         }
-        static get code() {
-          return "ERR_JOSE_GENERIC";
-        }
       };
       JWTClaimValidationFailed = class extends JOSEError {
+        static get code() {
+          return "ERR_JWT_CLAIM_VALIDATION_FAILED";
+        }
         constructor(message2, claim = "unspecified", reason = "unspecified") {
           super(message2);
           this.code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
           this.claim = claim;
           this.reason = reason;
         }
-        static get code() {
-          return "ERR_JWT_CLAIM_VALIDATION_FAILED";
-        }
       };
       JWTExpired = class extends JOSEError {
+        static get code() {
+          return "ERR_JWT_EXPIRED";
+        }
         constructor(message2, claim = "unspecified", reason = "unspecified") {
           super(message2);
           this.code = "ERR_JWT_EXPIRED";
           this.claim = claim;
           this.reason = reason;
         }
-        static get code() {
-          return "ERR_JWT_EXPIRED";
-        }
       };
       JOSEAlgNotAllowed = class extends JOSEError {
         constructor() {
@@ -8229,7 +8233,9 @@ ${newlined}
                 }
               }
               return true;
-            }, w.prototype.clone = function Wt() {
+            }, w.prototype.clone = /*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+             */
+            function Wt() {
               var t3 = F();
               return this.copyTo(t3), t3;
             }, w.prototype.intValue = function zt() {
@@ -8622,7 +8628,9 @@ ${newlined}
                 default:
                   return null;
               }
-            }, He.prototype.getByteLength = function() {
+            }, /*! (c) Stefan Thomas | https://github.com/bitcoinjs/bitcoinjs-lib
+             */
+            He.prototype.getByteLength = function() {
               return Math.floor((this.toBigInteger().bitLength() + 7) / 8);
             }, Ve.prototype.getEncoded = function(t3) {
               var e2 = function t4(e3, r4) {
@@ -14626,15 +14634,36 @@ ${newlined}
     "../node_modules/rdf-canonize/lib/IdentifierIssuer.js"(exports, module2) {
       "use strict";
       module2.exports = class IdentifierIssuer {
+        /**
+         * Creates a new IdentifierIssuer. A IdentifierIssuer issues unique
+         * identifiers, keeping track of any previously issued identifiers.
+         *
+         * @param prefix the prefix to use ('<prefix><counter>').
+         * @param existing an existing Map to use.
+         * @param counter the counter to use.
+         */
         constructor(prefix, existing = /* @__PURE__ */ new Map(), counter = 0) {
           this.prefix = prefix;
           this._existing = existing;
           this.counter = counter;
         }
+        /**
+         * Copies this IdentifierIssuer.
+         *
+         * @return a copy of this IdentifierIssuer.
+         */
         clone() {
           const { prefix, _existing, counter } = this;
           return new IdentifierIssuer(prefix, new Map(_existing), counter);
         }
+        /**
+         * Gets the new identifier for the given old identifier, where if no old
+         * identifier is given a new identifier will be generated.
+         *
+         * @param [old] the old identifier to get the new identifier for.
+         *
+         * @return the new identifier.
+         */
         getId(old) {
           const existing = old && this._existing.get(old);
           if (existing) {
@@ -14647,9 +14676,24 @@ ${newlined}
           }
           return identifier;
         }
+        /**
+         * Returns true if the given old identifer has already been assigned a new
+         * identifier.
+         *
+         * @param old the old identifier to check.
+         *
+         * @return true if the old identifier has been assigned a new identifier,
+         *   false if not.
+         */
         hasId(old) {
           return this._existing.has(old);
         }
+        /**
+         * Returns all of the IDs that have been issued new IDs in the order in
+         * which they were issued new IDs.
+         *
+         * @return the list of old IDs that has been issued new IDs in order.
+         */
         getOldIds() {
           return [...this._existing.keys()];
         }
@@ -14812,6 +14856,11 @@ ${newlined}
       require_setImmediate();
       var crypto2 = self.crypto || self.msCrypto;
       module2.exports = class MessageDigest {
+        /**
+         * Creates a new MessageDigest.
+         *
+         * @param algorithm the algorithm to use.
+         */
         constructor(algorithm) {
           if (!(crypto2 && crypto2.subtle)) {
             throw new Error("crypto.subtle not found.");
@@ -14848,6 +14897,12 @@ ${newlined}
     "../node_modules/rdf-canonize/lib/Permuter.js"(exports, module2) {
       "use strict";
       module2.exports = class Permuter {
+        /**
+         * A Permuter iterates over all possible permutations of the given array
+         * of elements.
+         *
+         * @param list the array of elements to iterate over.
+         */
         constructor(list) {
           this.current = list.sort();
           this.done = false;
@@ -14856,9 +14911,20 @@ ${newlined}
             this.dir.set(list[i], true);
           }
         }
+        /**
+         * Returns true if there is another permutation.
+         *
+         * @return true if there is another permutation, false if not.
+         */
         hasNext() {
           return !this.done;
         }
+        /**
+         * Gets the next permutation. Call hasNext() to ensure there is another one
+         * first.
+         *
+         * @return the next permutation.
+         */
         next() {
           const { current, dir: dir2 } = this;
           const rval = current.slice();
@@ -14927,6 +14993,13 @@ ${newlined}
         );
       })();
       module2.exports = class NQuads {
+        /**
+         * Parses RDF in the form of N-Quads.
+         *
+         * @param input the N-Quads input to parse.
+         *
+         * @return an RDF dataset (an array of quads per http://rdf.js.org/).
+         */
         static parse(input) {
           const dataset = [];
           const graphs = {};
@@ -15006,6 +15079,13 @@ ${newlined}
           }
           return dataset;
         }
+        /**
+         * Converts an RDF dataset to N-Quads.
+         *
+         * @param dataset (array of quads) the RDF dataset to convert.
+         *
+         * @return the N-Quads string.
+         */
         static serialize(dataset) {
           if (!Array.isArray(dataset)) {
             dataset = NQuads.legacyDatasetToQuads(dataset);
@@ -15016,6 +15096,16 @@ ${newlined}
           }
           return quads.sort().join("");
         }
+        /**
+         * Converts RDF quad components to an N-Quad string (a single quad).
+         *
+         * @param {Object} s - N-Quad subject component.
+         * @param {Object} p - N-Quad predicate component.
+         * @param {Object} o - N-Quad object component.
+         * @param {Object} g - N-Quad graph component.
+         *
+         * @return {string} the N-Quad.
+         */
         static serializeQuadComponents(s, p, o, g) {
           let nquad = "";
           if (s.termType === TYPE_NAMED_NODE) {
@@ -15046,6 +15136,13 @@ ${newlined}
           nquad += " .\n";
           return nquad;
         }
+        /**
+         * Converts an RDF quad to an N-Quad string (a single quad).
+         *
+         * @param quad the RDF quad convert.
+         *
+         * @return the N-Quad string.
+         */
         static serializeQuad(quad5) {
           return NQuads.serializeQuadComponents(
             quad5.subject,
@@ -15054,6 +15151,14 @@ ${newlined}
             quad5.graph
           );
         }
+        /**
+         * Converts a legacy-formatted dataset to an array of quads dataset per
+         * http://rdf.js.org/.
+         *
+         * @param dataset the legacy dataset to convert.
+         *
+         * @return the array of quads dataset.
+         */
         static legacyDatasetToQuads(dataset) {
           const quads = [];
           const termTypeMap = {
@@ -15188,6 +15293,7 @@ ${newlined}
           this.quads = null;
           this.deepIterations = null;
         }
+        // 4.4) Normalization Algorithm
         async main(dataset) {
           this.deepIterations = /* @__PURE__ */ new Map();
           this.quads = dataset;
@@ -15248,6 +15354,7 @@ ${newlined}
           normalized.sort();
           return normalized.join("");
         }
+        // 4.6) Hash First Degree Quads
         async hashFirstDegreeQuads(id3) {
           const nquads = [];
           const info2 = this.blankNodeInfo.get(id3);
@@ -15284,6 +15391,7 @@ ${newlined}
           info2.hash = await md.digest();
           return info2.hash;
         }
+        // 4.7) Hash Related Blank Node
         async hashRelatedBlankNode(related, quad5, issuer, position) {
           let id3;
           if (this.canonicalIssuer.hasId(related)) {
@@ -15301,6 +15409,7 @@ ${newlined}
           md.update(id3);
           return md.digest();
         }
+        // 4.8) Hash N-Degree Quads
         async hashNDegreeQuads(id3, issuer) {
           const deepIterations = this.deepIterations.get(id3) || 0;
           if (deepIterations > this.maxDeepIterations) {
@@ -15367,6 +15476,7 @@ ${newlined}
           }
           return { hash: await md.digest(), issuer };
         }
+        // helper for modifying component during Hash First Degree Quads
         modifyFirstDegreeComponent(id3, component) {
           if (component.termType !== "BlankNode") {
             return component;
@@ -15376,9 +15486,11 @@ ${newlined}
             value: component.value === id3 ? "_:a" : "_:z"
           };
         }
+        // helper for getting a related predicate
         getRelatedPredicate(quad5) {
           return `<${quad5.predicate.value}>`;
         }
+        // helper for creating hash to related blank nodes map
         async createHashToRelated(id3, issuer) {
           const hashToRelated = /* @__PURE__ */ new Map();
           const quads = this.blankNodeInfo.get(id3).quads;
@@ -15455,6 +15567,7 @@ ${newlined}
             hashToRelated.set(hash, [related]);
           }
         }
+        // canonical ids for 7.1
         _componentWithCanonicalId(component) {
           if (component.termType === "BlankNode" && !component.value.startsWith(this.canonicalIssuer.prefix)) {
             return {
@@ -15486,6 +15599,7 @@ ${newlined}
           this.name = "URGNA2012";
           this.createMessageDigest = () => new MessageDigest("sha1");
         }
+        // helper for modifying component during Hash First Degree Quads
         modifyFirstDegreeComponent(id3, component, key) {
           if (component.termType !== "BlankNode") {
             return component;
@@ -15501,9 +15615,11 @@ ${newlined}
             value: component.value === id3 ? "_:a" : "_:z"
           };
         }
+        // helper for getting a related predicate
         getRelatedPredicate(quad5) {
           return quad5.predicate.value;
         }
+        // helper for creating hash to related blank nodes map
         async createHashToRelated(id3, issuer) {
           const hashToRelated = /* @__PURE__ */ new Map();
           const quads = this.blankNodeInfo.get(id3).quads;
@@ -15563,6 +15679,7 @@ ${newlined}
           this.quads = null;
           this.deepIterations = null;
         }
+        // 4.4) Normalization Algorithm
         main(dataset) {
           this.deepIterations = /* @__PURE__ */ new Map();
           this.quads = dataset;
@@ -15619,6 +15736,7 @@ ${newlined}
           normalized.sort();
           return normalized.join("");
         }
+        // 4.6) Hash First Degree Quads
         hashFirstDegreeQuads(id3) {
           const nquads = [];
           const info2 = this.blankNodeInfo.get(id3);
@@ -15655,6 +15773,7 @@ ${newlined}
           info2.hash = md.digest();
           return info2.hash;
         }
+        // 4.7) Hash Related Blank Node
         hashRelatedBlankNode(related, quad5, issuer, position) {
           let id3;
           if (this.canonicalIssuer.hasId(related)) {
@@ -15672,6 +15791,7 @@ ${newlined}
           md.update(id3);
           return md.digest();
         }
+        // 4.8) Hash N-Degree Quads
         hashNDegreeQuads(id3, issuer) {
           const deepIterations = this.deepIterations.get(id3) || 0;
           if (deepIterations > this.maxDeepIterations) {
@@ -15734,6 +15854,7 @@ ${newlined}
           }
           return { hash: md.digest(), issuer };
         }
+        // helper for modifying component during Hash First Degree Quads
         modifyFirstDegreeComponent(id3, component) {
           if (component.termType !== "BlankNode") {
             return component;
@@ -15743,9 +15864,11 @@ ${newlined}
             value: component.value === id3 ? "_:a" : "_:z"
           };
         }
+        // helper for getting a related predicate
         getRelatedPredicate(quad5) {
           return `<${quad5.predicate.value}>`;
         }
+        // helper for creating hash to related blank nodes map
         createHashToRelated(id3, issuer) {
           const hashToRelated = /* @__PURE__ */ new Map();
           const quads = this.blankNodeInfo.get(id3).quads;
@@ -15811,6 +15934,7 @@ ${newlined}
             hashToRelated.set(hash, [related]);
           }
         }
+        // canonical ids for 7.1
         _componentWithCanonicalId({ component }) {
           if (component.termType === "BlankNode" && !component.value.startsWith(this.canonicalIssuer.prefix)) {
             return {
@@ -15839,6 +15963,7 @@ ${newlined}
           this.name = "URGNA2012";
           this.createMessageDigest = () => new MessageDigest("sha1");
         }
+        // helper for modifying component during Hash First Degree Quads
         modifyFirstDegreeComponent(id3, component, key) {
           if (component.termType !== "BlankNode") {
             return component;
@@ -15854,9 +15979,11 @@ ${newlined}
             value: component.value === id3 ? "_:a" : "_:z"
           };
         }
+        // helper for getting a related predicate
         getRelatedPredicate(quad5) {
           return quad5.predicate.value;
         }
+        // helper for creating hash to related blank nodes map
         createHashToRelated(id3, issuer) {
           const hashToRelated = /* @__PURE__ */ new Map();
           const quads = this.blankNodeInfo.get(id3).quads;
@@ -16022,8 +16149,14 @@ ${newlined}
         return false;
       };
       api.isSubjectReference = (v) => types2.isObject(v) && Object.keys(v).length === 1 && "@id" in v;
-      api.isValue = (v) => types2.isObject(v) && "@value" in v;
-      api.isList = (v) => types2.isObject(v) && "@list" in v;
+      api.isValue = (v) => // Note: A value is a @value if all of these hold true:
+      // 1. It is an Object.
+      // 2. It has the @value property.
+      types2.isObject(v) && "@value" in v;
+      api.isList = (v) => // Note: A value is a @list if all of these hold true:
+      // 1. It is an Object.
+      // 2. It has the @list property.
+      types2.isObject(v) && "@list" in v;
       api.isGraph = (v) => {
         return types2.isObject(v) && "@graph" in v && Object.keys(v).filter((key) => key !== "@id" && key !== "@index").length === 1;
       };
@@ -16047,6 +16180,13 @@ ${newlined}
     "../node_modules/jsonld/lib/JsonLdError.js"(exports, module2) {
       "use strict";
       module2.exports = class JsonLdError extends Error {
+        /**
+         * Creates a JSON-LD Error.
+         *
+         * @param msg the error message.
+         * @param type the error type.
+         * @param details the error details.
+         */
         constructor(message2 = "An unspecified JSON-LD error occurred.", name = "jsonld.Error", details = {}) {
           super(message2);
           this.name = name;
@@ -16316,6 +16456,7 @@ ${newlined}
       var RDF2 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
       var XSD2 = "http://www.w3.org/2001/XMLSchema#";
       module2.exports = {
+        // TODO: Deprecated and will be removed later. Use LINK_HEADER_CONTEXT.
         LINK_HEADER_REL: "http://www.w3.org/ns/json-ld#context",
         LINK_HEADER_CONTEXT: "http://www.w3.org/ns/json-ld#context",
         RDF: RDF2,
@@ -16343,6 +16484,9 @@ ${newlined}
     "../node_modules/jsonld/lib/RequestQueue.js"(exports, module2) {
       "use strict";
       module2.exports = class RequestQueue {
+        /**
+         * Creates a simple queue for requesting documents.
+         */
         constructor() {
           this._requests = {};
         }
@@ -16378,6 +16522,7 @@ ${newlined}
       module2.exports = api;
       api.parsers = {
         simple: {
+          // RFC 3986 basic parts
           keys: [
             "href",
             "scheme",
@@ -16386,6 +16531,7 @@ ${newlined}
             "query",
             "fragment"
           ],
+          /* eslint-disable-next-line max-len */
           regex: /^(?:([^:\/?#]+):)?(?:\/\/([^\/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/
         },
         full: {
@@ -16405,6 +16551,7 @@ ${newlined}
             "query",
             "fragment"
           ],
+          /* eslint-disable-next-line max-len */
           regex: /^(([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?(?:(((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/
         }
       };
@@ -16693,9 +16840,9 @@ ${newlined}
     }
   });
 
-  // ../node_modules/yallist/iterator.js
+  // ../node_modules/jsonld/node_modules/yallist/iterator.js
   var require_iterator = __commonJS({
-    "../node_modules/yallist/iterator.js"(exports, module2) {
+    "../node_modules/jsonld/node_modules/yallist/iterator.js"(exports, module2) {
       "use strict";
       module2.exports = function(Yallist) {
         Yallist.prototype[Symbol.iterator] = function* () {
@@ -16707,9 +16854,9 @@ ${newlined}
     }
   });
 
-  // ../node_modules/yallist/yallist.js
+  // ../node_modules/jsonld/node_modules/yallist/yallist.js
   var require_yallist = __commonJS({
-    "../node_modules/yallist/yallist.js"(exports, module2) {
+    "../node_modules/jsonld/node_modules/yallist/yallist.js"(exports, module2) {
       "use strict";
       module2.exports = Yallist;
       Yallist.Node = Node3;
@@ -17076,9 +17223,9 @@ ${newlined}
     }
   });
 
-  // ../node_modules/lru-cache/index.js
+  // ../node_modules/jsonld/node_modules/lru-cache/index.js
   var require_lru_cache = __commonJS({
-    "../node_modules/lru-cache/index.js"(exports, module2) {
+    "../node_modules/jsonld/node_modules/lru-cache/index.js"(exports, module2) {
       "use strict";
       var Yallist = require_yallist();
       var MAX = Symbol("max");
@@ -17112,6 +17259,7 @@ ${newlined}
           this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
           this.reset();
         }
+        // resize the cache when the max changes.
         set max(mL) {
           if (typeof mL !== "number" || mL < 0)
             throw new TypeError("max must be a non-negative number");
@@ -17136,6 +17284,7 @@ ${newlined}
         get maxAge() {
           return this[MAX_AGE];
         }
+        // resize the cache when the lengthCalculator changes.
         set lengthCalculator(lC) {
           if (typeof lC !== "function")
             lC = naiveLength;
@@ -17351,6 +17500,11 @@ ${newlined}
       var LRU = require_lru_cache();
       var MAX_ACTIVE_CONTEXTS = 10;
       module2.exports = class ResolvedContext {
+        /**
+         * Creates a ResolvedContext.
+         *
+         * @param document the context document.
+         */
         constructor({ document: document3 }) {
           this.document = document3;
           this.cache = new LRU({ max: MAX_ACTIVE_CONTEXTS });
@@ -17382,6 +17536,11 @@ ${newlined}
       var ResolvedContext = require_ResolvedContext();
       var MAX_CONTEXT_URLS = 10;
       module2.exports = class ContextResolver {
+        /**
+         * Creates a ContextResolver.
+         *
+         * @param sharedCache a shared LRU cache with `get` and `set` APIs.
+         */
         constructor({ sharedCache }) {
           this.perOpCache = /* @__PURE__ */ new Map();
           this.sharedCache = sharedCache;
@@ -19352,6 +19511,7 @@ ${newlined}
             });
           } else if (container.includes("@type") && _isObject(value)) {
             expandedValue = await _expandIndexMap({
+              // since container is `@type`, revert type scoped context when expanding
               activeCtx: termCtx.revertToPreviousContext(),
               options,
               activeProperty: key,
@@ -19895,12 +20055,18 @@ ${newlined}
       var types2 = require_types();
       var util = require_util();
       var {
+        // RDF,
         RDF_LIST,
         RDF_FIRST,
         RDF_REST,
         RDF_NIL,
         RDF_TYPE,
+        // RDF_PLAIN_LITERAL,
+        // RDF_XML_LITERAL,
         RDF_JSON_LITERAL,
+        // RDF_OBJECT,
+        // RDF_LANGSTRING,
+        // XSD,
         XSD_BOOLEAN,
         XSD_DOUBLE,
         XSD_INTEGER,
@@ -20121,12 +20287,18 @@ ${newlined}
       var types2 = require_types();
       var util = require_util();
       var {
+        // RDF,
+        // RDF_LIST,
         RDF_FIRST,
         RDF_REST,
         RDF_NIL,
         RDF_TYPE,
+        // RDF_PLAIN_LITERAL,
+        // RDF_XML_LITERAL,
         RDF_JSON_LITERAL,
+        // RDF_OBJECT,
         RDF_LANGSTRING,
+        // XSD,
         XSD_BOOLEAN,
         XSD_DOUBLE,
         XSD_INTEGER,
@@ -22553,10 +22725,9 @@ ${newlined}
               return iterable;
             if (!isNaN(iterable.length)) {
               var i = -1, next = function next2() {
-                for (; ++i < iterable.length; ) {
+                for (; ++i < iterable.length; )
                   if (hasOwn.call(iterable, i))
                     return next2.value = iterable[i], next2.done = false, next2;
-                }
                 return next2.value = void 0, next2.done = true, next2;
               };
               return next.next = next;
@@ -22601,9 +22772,8 @@ ${newlined}
           return "[object Generator]";
         }), exports2.keys = function(val) {
           var object = Object(val), keys = [];
-          for (var key in object) {
+          for (var key in object)
             keys.push(key);
-          }
           return keys.reverse(), function next() {
             for (; keys.length; ) {
               var key2 = keys.pop();
@@ -22616,9 +22786,8 @@ ${newlined}
           constructor: Context,
           reset: function reset(skipTempReset) {
             if (this.prev = 0, this.next = 0, this.sent = this._sent = void 0, this.done = false, this.delegate = null, this.method = "next", this.arg = void 0, this.tryEntries.forEach(resetTryEntry), !skipTempReset)
-              for (var name in this) {
+              for (var name in this)
                 "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = void 0);
-              }
           },
           stop: function stop() {
             this.done = true;
@@ -22763,22 +22932,97 @@ ${newlined}
         return target;
       }
       var MIME_TYPE = freeze({
+        /**
+         * `text/html`, the only mime type that triggers treating an XML document as HTML.
+         *
+         * @see DOMParser.SupportedType.isHTML
+         * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+         * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+         * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+         */
         HTML: "text/html",
+        /**
+         * Helper method to check a mime type if it indicates an HTML document
+         *
+         * @param {string} [value]
+         * @returns {boolean}
+         *
+         * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+         * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+         * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring 	 */
         isHTML: function(value) {
           return value === MIME_TYPE.HTML;
         },
+        /**
+         * `application/xml`, the standard mime type for XML documents.
+         *
+         * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+         * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+         * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+         */
         XML_APPLICATION: "application/xml",
+        /**
+         * `text/html`, an alias for `application/xml`.
+         *
+         * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+         * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+         * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+         */
         XML_TEXT: "text/xml",
+        /**
+         * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+         * but is parsed as an XML document.
+         *
+         * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+         * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+         * @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+         */
         XML_XHTML_APPLICATION: "application/xhtml+xml",
+        /**
+         * `image/svg+xml`,
+         *
+         * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+         * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+         * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+         */
         XML_SVG_IMAGE: "image/svg+xml"
       });
       var NAMESPACE = freeze({
+        /**
+         * The XHTML namespace.
+         *
+         * @see http://www.w3.org/1999/xhtml
+         */
         HTML: "http://www.w3.org/1999/xhtml",
+        /**
+         * Checks if `uri` equals `NAMESPACE.HTML`.
+         *
+         * @param {string} [uri]
+         *
+         * @see NAMESPACE.HTML
+         */
         isHTML: function(uri) {
           return uri === NAMESPACE.HTML;
         },
+        /**
+         * The SVG namespace.
+         *
+         * @see http://www.w3.org/2000/svg
+         */
         SVG: "http://www.w3.org/2000/svg",
+        /**
+         * The `xml:` namespace.
+         *
+         * @see http://www.w3.org/XML/1998/namespace
+         */
         XML: "http://www.w3.org/XML/1998/namespace",
+        /**
+         * The `xmlns:` namespace
+         *
+         * @see https://www.w3.org/2000/xmlns/
+         */
         XMLNS: "http://www.w3.org/2000/xmlns/"
       });
       exports.assign = assign;
@@ -22894,7 +23138,19 @@ ${newlined}
       function NodeList() {
       }
       NodeList.prototype = {
+        /**
+         * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
+         * @standard level1
+         */
         length: 0,
+        /**
+         * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
+         * @standard level1
+         * @param index  unsigned long
+         *   Index into the collection.
+         * @return Node
+         * 	The node at the indexth position in the NodeList, or null if that is not a valid index.
+         */
         item: function(index2) {
           return this[index2] || null;
         },
@@ -22904,9 +23160,19 @@ ${newlined}
           }
           return buf.join("");
         },
+        /**
+         * @private
+         * @param {function (Node):boolean} predicate
+         * @returns {Node[]}
+         */
         filter: function(predicate) {
           return Array.prototype.filter.call(this, predicate);
         },
+        /**
+         * @private
+         * @param {Node} item
+         * @returns {number}
+         */
         indexOf: function(item) {
           return Array.prototype.indexOf.call(this, item);
         }
@@ -22995,6 +23261,7 @@ ${newlined}
           _addNamedNode(this._ownerElement, this, attr, oldAttr);
           return oldAttr;
         },
+        /* returns Node */
         setNamedItemNS: function(attr) {
           var el = attr.ownerElement, oldAttr;
           if (el && el != this._ownerElement) {
@@ -23004,11 +23271,14 @@ ${newlined}
           _addNamedNode(this._ownerElement, this, attr, oldAttr);
           return oldAttr;
         },
+        /* returns Node */
         removeNamedItem: function(key) {
           var attr = this.getNamedItem(key);
           _removeNamedNode(this._ownerElement, this, attr);
           return attr;
         },
+        // raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
+        //for level2
         removeNamedItemNS: function(namespaceURI, localName) {
           var attr = this.getNamedItemNS(namespaceURI, localName);
           _removeNamedNode(this._ownerElement, this, attr);
@@ -23028,9 +23298,46 @@ ${newlined}
       function DOMImplementation() {
       }
       DOMImplementation.prototype = {
+        /**
+         * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.
+         * The different implementations fairly diverged in what kind of features were reported.
+         * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.
+         *
+         * @deprecated It is deprecated and modern browsers return true in all cases.
+         *
+         * @param {string} feature
+         * @param {string} [version]
+         * @returns {boolean} always true
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN
+         * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core
+         * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard
+         */
         hasFeature: function(feature, version) {
           return true;
         },
+        /**
+         * Creates an XML Document object of the specified type with its document element.
+         *
+         * __It behaves slightly different from the description in the living standard__:
+         * - There is no interface/class `XMLDocument`, it returns a `Document` instance.
+         * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+         * - this implementation is not validating names or qualified names
+         *   (when parsing XML strings, the SAX parser takes care of that)
+         *
+         * @param {string|null} namespaceURI
+         * @param {string} qualifiedName
+         * @param {DocumentType=null} doctype
+         * @returns {Document}
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN
+         * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)
+         * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument  DOM Level 2 Core
+         *
+         * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+         * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+         * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+         */
         createDocument: function(namespaceURI, qualifiedName, doctype) {
           var doc = new Document();
           doc.implementation = this;
@@ -23045,6 +23352,27 @@ ${newlined}
           }
           return doc;
         },
+        /**
+         * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
+         *
+         * __This behavior is slightly different from the in the specs__:
+         * - this implementation is not validating names or qualified names
+         *   (when parsing XML strings, the SAX parser takes care of that)
+         *
+         * @param {string} qualifiedName
+         * @param {string} [publicId]
+         * @param {string} [systemId]
+         * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation
+         * 				  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN
+         * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core
+         * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard
+         *
+         * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+         * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+         * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+         */
         createDocumentType: function(qualifiedName, publicId, systemId) {
           var node = new DocumentType();
           node.name = qualifiedName;
@@ -23069,6 +23397,7 @@ ${newlined}
         namespaceURI: null,
         prefix: null,
         localName: null,
+        // Modified in DOM Level 2:
         insertBefore: function(newChild, refChild) {
           return _insertBefore(this, newChild, refChild);
         },
@@ -23090,6 +23419,7 @@ ${newlined}
         cloneNode: function(deep) {
           return cloneNode(this.ownerDocument || this, this, deep);
         },
+        // Modified in DOM Level 2:
         normalize: function() {
           var child = this.firstChild;
           while (child) {
@@ -23103,12 +23433,28 @@ ${newlined}
             }
           }
         },
+        // Introduced in DOM Level 2:
         isSupported: function(feature, version) {
           return this.ownerDocument.implementation.hasFeature(feature, version);
         },
+        // Introduced in DOM Level 2:
         hasAttributes: function() {
           return this.attributes.length > 0;
         },
+        /**
+         * Look up the prefix associated to the given namespace URI, starting from this node.
+         * **The default namespace declarations are ignored by this method.**
+         * See Namespace Prefix Lookup for details on the algorithm used by this method.
+         *
+         * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._
+         *
+         * @param {string | null} namespaceURI
+         * @returns {string | null}
+         * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix
+         * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo
+         * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix
+         * @see https://github.com/xmldom/xmldom/issues/322
+         */
         lookupPrefix: function(namespaceURI) {
           var el = this;
           while (el) {
@@ -23124,6 +23470,7 @@ ${newlined}
           }
           return null;
         },
+        // Introduced in DOM Level 3:
         lookupNamespaceURI: function(prefix) {
           var el = this;
           while (el) {
@@ -23137,6 +23484,7 @@ ${newlined}
           }
           return null;
         },
+        // Introduced in DOM Level 3:
         isDefaultNamespace: function(namespaceURI) {
           var prefix = this.lookupPrefix(namespaceURI);
           return prefix == null;
@@ -23254,7 +23602,8 @@ ${newlined}
         if (child && child.parentNode !== parent2) {
           throw new DOMException(NOT_FOUND_ERR, "child not in parent");
         }
-        if (!hasInsertableNodeType(node) || isDocTypeNode(node) && parent2.nodeType !== Node3.DOCUMENT_NODE) {
+        if (// 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.
+        !hasInsertableNodeType(node) || isDocTypeNode(node) && parent2.nodeType !== Node3.DOCUMENT_NODE) {
           throw new DOMException(
             HIERARCHY_REQUEST_ERR,
             "Unexpected node type " + node.nodeType + " for parent node type " + parent2.nodeType
@@ -23379,8 +23728,15 @@ ${newlined}
         return newChild;
       }
       Document.prototype = {
+        //implementation : null,
         nodeName: "#document",
         nodeType: DOCUMENT_NODE,
+        /**
+         * The DocumentType node of the document.
+         *
+         * @readonly
+         * @type DocumentType
+         */
         doctype: null,
         documentElement: null,
         _inc: 1,
@@ -23417,9 +23773,11 @@ ${newlined}
             this.documentElement = newChild;
           }
         },
+        // Introduced in DOM Level 2:
         importNode: function(importedNode, deep) {
           return importNode(this, importedNode, deep);
         },
+        // Introduced in DOM Level 2:
         getElementById: function(id3) {
           var rtv = null;
           _visitNode(this.documentElement, function(node) {
@@ -23432,6 +23790,23 @@ ${newlined}
           });
           return rtv;
         },
+        /**
+         * The `getElementsByClassName` method of `Document` interface returns an array-like object
+         * of all child elements which have **all** of the given class name(s).
+         *
+         * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.
+         *
+         *
+         * Warning: This is a live LiveNodeList.
+         * Changes in the DOM will reflect in the array as the changes occur.
+         * If an element selected by this array no longer qualifies for the selector,
+         * it will automatically be removed. Be aware of this for iteration purposes.
+         *
+         * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName
+         * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname
+         */
         getElementsByClassName: function(classNames) {
           var classNamesSet = toOrderedSet(classNames);
           return new LiveNodeList(this, function(base) {
@@ -23456,6 +23831,7 @@ ${newlined}
             return ls;
           });
         },
+        //document factory method:
         createElement: function(tagName) {
           var node = new Element();
           node.ownerDocument = this;
@@ -23513,6 +23889,7 @@ ${newlined}
           node.nodeName = name;
           return node;
         },
+        // Introduced in DOM Level 2:
         createElementNS: function(namespaceURI, qualifiedName) {
           var node = new Element();
           var pl = qualifiedName.split(":");
@@ -23531,6 +23908,7 @@ ${newlined}
           attrs._ownerElement = node;
           return node;
         },
+        // Introduced in DOM Level 2:
         createAttributeNS: function(namespaceURI, qualifiedName) {
           var node = new Attr();
           var pl = qualifiedName.split(":");
@@ -23573,6 +23951,7 @@ ${newlined}
           var attr = this.getAttributeNode(name);
           attr && this.removeAttributeNode(attr);
         },
+        //four real opeartion method
         appendChild: function(newChild) {
           if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
             return this.insertBefore(newChild, null);
@@ -23589,6 +23968,7 @@ ${newlined}
         removeAttributeNode: function(oldAttr) {
           return this.attributes.removeNamedItem(oldAttr.nodeName);
         },
+        //get real attribute name,and remove it by removeAttributeNode
         removeAttributeNS: function(namespaceURI, localName) {
           var old = this.getAttributeNodeNS(namespaceURI, localName);
           old && this.removeAttributeNode(old);
@@ -23742,6 +24122,7 @@ ${newlined}
           if (prefix == null) {
             var visibleNamespaces = [
               { namespace: uri, prefix: null }
+              //{namespace:uri,prefix:''}
             ];
           }
         }
@@ -24501,6 +24882,10 @@ ${newlined}
           }
           el.addValue(
             qname,
+            // @see https://www.w3.org/TR/xml/#AVNormalize
+            // since the xmldom sax parser does not "interpret" DTD the following is not implemented:
+            // - recursive replacement of (DTD) entity references
+            // - trimming and collapsing multiple spaces into a single one for attributes that are not of type CDATA
             value2.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, entityReplacer),
             startIndex
           );
@@ -24848,6 +25233,16 @@ ${newlined}
         getValue: function(i) {
           return this[i].value;
         }
+        //	,getIndex:function(uri, localName)){
+        //		if(localName){
+        //
+        //		}else{
+        //			var qName = uri
+        //		}
+        //	},
+        //	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
+        //	getType:function(uri,localName){}
+        //	getType:function(i){},
       };
       function split(source, start) {
         var match;
@@ -25013,6 +25408,7 @@ ${newlined}
             locator.lineNumber = 0;
           }
         },
+        //LexicalHandler
         comment: function(chars, start, length) {
           chars = _toString.apply(this, arguments);
           var comm = this.doc.createComment(chars);
@@ -25034,6 +25430,10 @@ ${newlined}
             this.doc.doctype = dt;
           }
         },
+        /**
+         * @see org.xml.sax.ErrorHandler
+         * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+         */
         warning: function(error2) {
           console.warn("[xmldom warning]	" + error2, _locator(this.locator));
         },
@@ -25106,6 +25506,7 @@ ${newlined}
         http: "http://www.w3.org/2007/ont/http#",
         httph: "http://www.w3.org/2007/ont/httph#",
         icalTZ: "http://www.w3.org/2002/12/cal/icaltzd#",
+        // Beware: not cal:
         ldp: "http://www.w3.org/ns/ldp#",
         link: "http://www.w3.org/2007/ont/link#",
         log: "http://www.w3.org/2000/10/swap/log#",
@@ -25123,6 +25524,7 @@ ${newlined}
         rss: "http://purl.org/rss/1.0/",
         sched: "http://www.w3.org/ns/pim/schedule#",
         schema: "http://schema.org/",
+        // @@ beware confusion with documents no 303
         sioc: "http://rdfs.org/sioc/ns#",
         solid: "http://www.w3.org/ns/solid/terms#",
         space: "http://www.w3.org/ns/pim/space#",
@@ -25176,6 +25578,8 @@ ${newlined}
     }
     async handleIncomingRedirect() {
       return this.session.handleIncomingRedirect({
+        // session restore disabled, due to
+        // https://github.com/inrupt/solid-client-authn-js/issues/1647
         restorePreviousSession: false
       });
     }
@@ -25407,6 +25811,11 @@ ${newlined}
         console.log("@@@ node substitute" + this);
         return this;
       }
+      /**
+       * Compares this node with another
+       * @see {equals} to check if two nodes are equal
+       * @param other - The other node
+       */
     }, {
       key: "compareTerm",
       value: function compareTerm(other) {
@@ -25424,6 +25833,10 @@ ${newlined}
         }
         return 0;
       }
+      /**
+       * Compares whether the two nodes are equal
+       * @param other The other node
+       */
     }, {
       key: "equals",
       value: function equals2(other) {
@@ -25432,31 +25845,51 @@ ${newlined}
         }
         return this.termType === other.termType && this.value === other.value;
       }
+      /**
+       * Creates a hash for this node
+       * @deprecated use {rdfFactory.id} instead if possible
+       */
     }, {
       key: "hashString",
       value: function hashString() {
         return this.toCanonical();
       }
+      /**
+       * Compares whether this node is the same as the other one
+       * @param other - Another node
+       */
     }, {
       key: "sameTerm",
       value: function sameTerm(other) {
         return this.equals(other);
       }
+      /**
+       * Creates a canonical string representation of this node
+       */
     }, {
       key: "toCanonical",
       value: function toCanonical() {
         return this.toNT();
       }
+      /**
+       * Creates a n-triples string representation of this node
+       */
     }, {
       key: "toNT",
       value: function toNT() {
         return this.toString();
       }
+      /**
+       * Creates a n-quads string representation of this node
+       */
     }, {
       key: "toNQ",
       value: function toNQ2() {
         return this.toNT();
       }
+      /**
+       * Creates a string representation of this node
+       */
     }, {
       key: "toString",
       value: function toString() {
@@ -25558,6 +25991,10 @@ ${newlined}
         }
         return 0;
       }
+      /**
+       * Gets a copy of this blank node in the specified formula
+       * @param formula The formula
+       */
     }, {
       key: "copy",
       value: function copy(formula2) {
@@ -25577,20 +26014,25 @@ ${newlined}
       }
     }], [{
       key: "getId",
-      value: function getId(id3) {
-        if (id3) {
-          if (typeof id3 !== "string") {
-            console.log("Bad blank id:", id3);
-            throw new Error("Bad id argument to new blank node: " + id3);
-          }
-          if (id3.includes("#")) {
-            var fragments = id3.split("#");
-            return fragments[fragments.length - 1];
+      value: (
+        /**
+         * The next unique identifier for blank nodes
+         */
+        function getId(id3) {
+          if (id3) {
+            if (typeof id3 !== "string") {
+              console.log("Bad blank id:", id3);
+              throw new Error("Bad id argument to new blank node: " + id3);
+            }
+            if (id3.includes("#")) {
+              var fragments = id3.split("#");
+              return fragments[fragments.length - 1];
+            }
+            return id3;
           }
-          return id3;
+          return "n" + BlankNode3.nextId++;
         }
-        return "n" + BlankNode3.nextId++;
-      }
+      )
     }]);
     return BlankNode3;
   }(Node2);
@@ -25706,6 +26148,10 @@ ${newlined}
           return null;
         return new NamedNode3(str.slice(0, p + 1));
       }
+      /**
+       * Returns an NN for the whole web site, ending in slash.
+       * Contrast with the "origin" which does NOT have a trailing slash
+       */
     }, {
       key: "site",
       value: function site() {
@@ -25720,6 +26166,10 @@ ${newlined}
           return new NamedNode3(str.slice(0, q + 1));
         }
       }
+      /**
+       * Creates the fetchable named node for the document.
+       * Removes everything from the # anchor tag.
+       */
     }, {
       key: "doc",
       value: function doc() {
@@ -25729,16 +26179,21 @@ ${newlined}
           return new NamedNode3(this.value.split("#")[0]);
         }
       }
+      /**
+       * Returns the URI including <brackets>
+       */
     }, {
       key: "toString",
       value: function toString() {
         return "<" + this.value + ">";
       }
+      /** The local identifier with the document */
     }, {
       key: "id",
       value: function id3() {
         return this.value.split("#")[1];
       }
+      /** Alias for value, favored by Tim */
     }, {
       key: "uri",
       get: function get() {
@@ -25747,6 +26202,10 @@ ${newlined}
       set: function set(uri) {
         this.value = uri;
       }
+      /**
+       * Creates a named node from the specified input value
+       * @param value - An input value
+       */
     }], [{
       key: "fromValue",
       value: function fromValue2(value) {
@@ -25829,6 +26288,10 @@ ${newlined}
       value: function copy() {
         return new Literal3(this.value, this.lang, this.datatype);
       }
+      /**
+       * Gets whether two literals are the same
+       * @param other The other statement
+       */
     }, {
       key: "equals",
       value: function equals2(other) {
@@ -25837,6 +26300,10 @@ ${newlined}
         }
         return this.termType === other.termType && this.value === other.value && this.language === other.language && (!this.datatype && !other.datatype || this.datatype && this.datatype.equals(other.datatype));
       }
+      /**
+       * The language for the literal
+       * @deprecated use {language} instead
+       */
     }, {
       key: "lang",
       get: function get() {
@@ -25850,11 +26317,16 @@ ${newlined}
       value: function toNT() {
         return Literal3.toNT(this);
       }
+      /** Serializes a literal to an N-Triples string */
     }, {
       key: "toString",
       value: function toString() {
         return "" + this.value;
       }
+      /**
+       * Builds a literal node from a boolean value
+       * @param value - The value
+       */
     }], [{
       key: "toNT",
       value: function toNT(literal4) {
@@ -25882,6 +26354,10 @@ ${newlined}
         var strValue = value ? "1" : "0";
         return new Literal3(strValue, null, xsd_internal_default.boolean);
       }
+      /**
+       * Builds a literal node from a date value
+       * @param value The value
+       */
     }, {
       key: "fromDate",
       value: function fromDate(value) {
@@ -25894,6 +26370,10 @@ ${newlined}
         var date = "" + value.getUTCFullYear() + "-" + d2(value.getUTCMonth() + 1) + "-" + d2(value.getUTCDate()) + "T" + d2(value.getUTCHours()) + ":" + d2(value.getUTCMinutes()) + ":" + d2(value.getUTCSeconds()) + "Z";
         return new Literal3(date, null, xsd_internal_default.dateTime);
       }
+      /**
+       * Builds a literal node from a number value
+       * @param value - The value
+       */
     }, {
       key: "fromNumber",
       value: function fromNumber(value) {
@@ -25909,6 +26389,10 @@ ${newlined}
         }
         return new Literal3(strValue, null, datatype);
       }
+      /**
+       * Builds a literal node from an input value
+       * @param value - The input value
+       */
     }, {
       key: "fromValue",
       value: function fromValue2(value) {
@@ -26002,22 +26486,36 @@ ${newlined}
       set: function set(value) {
         this.value = value;
       }
+      /**
+       * Appends an element to this collection
+       * @param element - The new element
+       */
     }, {
       key: "append",
       value: function append(element) {
         return this.elements.push(element);
       }
+      /**
+       * Closes this collection
+       */
     }, {
       key: "close",
       value: function close() {
         this.closed = true;
         return this.closed;
       }
+      /**
+       * Removes the first element from the collection (and return it)
+       */
     }, {
       key: "shift",
       value: function shift() {
         return this.elements.shift();
       }
+      /**
+       * Creates a new Collection with the substituting bindings applied
+       * @param bindings - The bindings to substitute
+       */
     }, {
       key: "substitute",
       value: function substitute(bindings) {
@@ -26033,9 +26531,19 @@ ${newlined}
       }
     }, {
       key: "toString",
-      value: function toString() {
-        return "(" + this.elements.join(" ") + ")";
-      }
+      value: (
+        /**
+         * Serializes the collection to a string.
+         * Surrounded by (parentheses) and separated by spaces.
+         */
+        function toString() {
+          return "(" + this.elements.join(" ") + ")";
+        }
+      )
+      /**
+       * Prepends the specified element to the collection's front
+       * @param element - The element to prepend
+       */
     }, {
       key: "unshift",
       value: function unshift(element) {
@@ -27840,6 +28348,7 @@ ${newlined}
     until,
     waterfall: waterfall$1,
     whilst: whilst$1,
+    // aliases
     all: every$1,
     allLimit: everyLimit$1,
     allSeries: everySeries$1,
@@ -27983,6 +28492,8 @@ ${newlined}
       this._comments = !!options.comments;
       this._literalClosingPos = 0;
     }
+    // ## Private methods
+    // ### `_tokenizeToEnd` tokenizes as for as possible, emitting tokens through the callback
     _tokenizeToEnd(callback, inputFinished) {
       let input = this._input;
       let currentLineLength = input.length;
@@ -28201,6 +28712,7 @@ ${newlined}
         callback(self2._syntaxError(/^\S*/.exec(input)[0]));
       }
     }
+    // ### `_unescape` replaces N3 escape codes by their corresponding characters
     _unescape(item) {
       let invalid = false;
       const replaced = item.replace(escapeSequence, (sequence, unicode4, unicode8, escapedChar) => {
@@ -28217,6 +28729,7 @@ ${newlined}
       });
       return invalid ? null : replaced;
     }
+    // ### `_parseLiteral` parses a literal into an unescaped value
     _parseLiteral(input) {
       if (input.length >= 3) {
         const opening = input.match(/^(?:"""|"|'''|'|)/)[0];
@@ -28241,6 +28754,7 @@ ${newlined}
       }
       return { value: "", matchLength: 0 };
     }
+    // ### `_syntaxError` creates a syntax error for the given issue
     _syntaxError(issue) {
       this._input = null;
       const err = new Error(`Unexpected "${issue}" on line ${this._line}.`);
@@ -28251,9 +28765,13 @@ ${newlined}
       };
       return err;
     }
+    // ### Strips off any starting UTF BOM mark.
     _readStartingBom(input) {
       return input.startsWith("\uFEFF") ? input.substr(1) : input;
     }
+    // ## Public methods
+    // ### `tokenize` starts the transformation of an N3 document into an array of tokens.
+    // The input can be a string or a stream.
     tokenize(input, callback) {
       this._line = 1;
       if (typeof input === "string") {
@@ -28321,17 +28839,22 @@ ${newlined}
     constructor(id3) {
       this.id = id3;
     }
+    // ### The value of this term
     get value() {
       return this.id;
     }
+    // ### Returns whether this object represents the same term as the other
     equals(other) {
       if (other instanceof Term)
         return this.id === other.id;
       return !!other && this.termType === other.termType && this.value === other.value;
     }
+    // ### Implement hashCode for Immutable.js, since we implement `equals`
+    // https://immutable-js.com/docs/v4.0.0/ValueObject/#hashCode()
     hashCode() {
       return 0;
     }
+    // ### Returns a plain object representation of this term
     toJSON() {
       return {
         termType: this.termType,
@@ -28340,30 +28863,37 @@ ${newlined}
     }
   };
   var NamedNode2 = class extends Term {
+    // ### The term type of this term
     get termType() {
       return "NamedNode";
     }
   };
   var Literal2 = class extends Term {
+    // ### The term type of this term
     get termType() {
       return "Literal";
     }
+    // ### The text value of this literal
     get value() {
       return this.id.substring(1, this.id.lastIndexOf('"'));
     }
+    // ### The language of this literal
     get language() {
       const id3 = this.id;
       let atPos = id3.lastIndexOf('"') + 1;
       return atPos < id3.length && id3[atPos++] === "@" ? id3.substr(atPos).toLowerCase() : "";
     }
+    // ### The datatype IRI of this literal
     get datatype() {
       return new NamedNode2(this.datatypeString);
     }
+    // ### The datatype string of this literal
     get datatypeString() {
       const id3 = this.id, dtPos = id3.lastIndexOf('"') + 1;
       const char = dtPos < id3.length ? id3[dtPos] : "";
       return char === "^" ? id3.substr(dtPos + 2) : char !== "@" ? xsd2.string : rdf.langString;
     }
+    // ### Returns whether this object represents the same term as the other
     equals(other) {
       if (other instanceof Literal2)
         return this.id === other.id;
@@ -28382,9 +28912,11 @@ ${newlined}
     constructor(name) {
       super(`_:${name}`);
     }
+    // ### The term type of this term
     get termType() {
       return "BlankNode";
     }
+    // ### The name of this blank node
     get value() {
       return this.id.substr(2);
     }
@@ -28393,9 +28925,11 @@ ${newlined}
     constructor(name) {
       super(`?${name}`);
     }
+    // ### The term type of this term
     get termType() {
       return "Variable";
     }
+    // ### The name of this variable
     get value() {
       return this.id.substr(1);
     }
@@ -28405,9 +28939,11 @@ ${newlined}
       super("");
       return DEFAULTGRAPH || this;
     }
+    // ### The term type of this term
     get termType() {
       return "DefaultGraph";
     }
+    // ### Returns whether this object represents the same term as the other
     equals(other) {
       return this === other || !!other && this.termType === other.termType;
     }
@@ -28421,6 +28957,7 @@ ${newlined}
       this._object = object;
       this._graph = graph3 || DEFAULTGRAPH;
     }
+    // ### The term type of this term
     get termType() {
       return "Quad";
     }
@@ -28436,6 +28973,7 @@ ${newlined}
     get graph() {
       return this._graph;
     }
+    // ### Returns a plain object representation of this quad
     toJSON() {
       return {
         termType: this.termType,
@@ -28445,6 +28983,7 @@ ${newlined}
         graph: this._graph.toJSON()
       };
     }
+    // ### Returns whether this object represents the same quad as the other
     equals(other) {
       return !!other && this._subject.equals(other.subject) && this._predicate.equals(other.predicate) && this._object.equals(other.object) && this._graph.equals(other.graph);
     }
@@ -28506,9 +29045,13 @@ ${newlined}
       this._lexer = options.lexer || new N3Lexer({ lineMode: isLineMode, n3: isN3 });
       this._explicitQuantifiers = !!options.explicitQuantifiers;
     }
+    // ## Static class methods
+    // ### `_resetBlankNodePrefix` restarts blank node prefix identification
     static _resetBlankNodePrefix() {
       blankNodePrefix = 0;
     }
+    // ## Private methods
+    // ### `_setBase` sets the base IRI to resolve relative IRIs
     _setBase(baseIRI) {
       if (!baseIRI) {
         this._base = "";
@@ -28524,6 +29067,8 @@ ${newlined}
         this._baseScheme = baseIRI[1];
       }
     }
+    // ### `_saveContext` stores the current parsing context
+    // when entering a new scope (list, blank node, formula)
     _saveContext(type, graph3, subject, predicate, object) {
       const n3Mode = this._n3Mode;
       this._contextStack.push({
@@ -28542,6 +29087,8 @@ ${newlined}
         this._quantified = Object.create(this._quantified);
       }
     }
+    // ### `_restoreContext` restores the parent context
+    // when leaving a scope (list, blank node, formula)
     _restoreContext(type, token) {
       const context = this._contextStack.pop();
       if (!context || context.type !== type)
@@ -28556,6 +29103,7 @@ ${newlined}
         this._quantified = context.quantified;
       }
     }
+    // ### `_readInTopContext` reads a token when in the top context
     _readInTopContext(token) {
       switch (token.type) {
         case "eof":
@@ -28584,6 +29132,7 @@ ${newlined}
           return this._readSubject(token);
       }
     }
+    // ### `_readEntity` reads an IRI, prefixed name, blank node, or variable
     _readEntity(token, quantifier) {
       let value;
       switch (token.type) {
@@ -28614,6 +29163,7 @@ ${newlined}
         value = this._quantified[value.id];
       return value;
     }
+    // ### `_readSubject` reads a quad's subject
     _readSubject(token) {
       this._predicate = null;
       switch (token.type) {
@@ -28680,6 +29230,7 @@ ${newlined}
       }
       return this._readPredicateOrNamedGraph;
     }
+    // ### `_readPredicate` reads a quad's predicate
     _readPredicate(token) {
       const type = token.type;
       switch (type) {
@@ -28717,6 +29268,7 @@ ${newlined}
       }
       return this._readObject;
     }
+    // ### `_readObject` reads a quad's object
     _readObject(token) {
       switch (token.type) {
         case "literal":
@@ -28764,15 +29316,18 @@ ${newlined}
       }
       return this._getContextEndReader();
     }
+    // ### `_readPredicateOrNamedGraph` reads a quad's predicate, or a named graph
     _readPredicateOrNamedGraph(token) {
       return token.type === "{" ? this._readGraph(token) : this._readPredicate(token);
     }
+    // ### `_readGraph` reads a graph
     _readGraph(token) {
       if (token.type !== "{")
         return this._error(`Expected graph but got ${token.type}`, token);
       this._graph = this._subject, this._subject = null;
       return this._readSubject;
     }
+    // ### `_readBlankNodeHead` reads the head of a blank node
     _readBlankNodeHead(token) {
       if (token.type === "]") {
         this._subject = null;
@@ -28782,6 +29337,7 @@ ${newlined}
         return this._readPredicate(token);
       }
     }
+    // ### `_readBlankNodeTail` reads the end of a blank node
     _readBlankNodeTail(token) {
       if (token.type !== "]")
         return this._readBlankNodePunctuation(token);
@@ -28796,6 +29352,7 @@ ${newlined}
       else
         return empty ? this._readPredicateOrNamedGraph : this._readPredicateAfterBlank;
     }
+    // ### `_readPredicateAfterBlank` reads a predicate after an anonymous blank node
     _readPredicateAfterBlank(token) {
       switch (token.type) {
         case ".":
@@ -28806,6 +29363,7 @@ ${newlined}
           return this._readPredicate(token);
       }
     }
+    // ### `_readListItem` reads items from a list
     _readListItem(token) {
       let item = null, list = null, next = this._readListItem;
       const previousList = this._subject, stack = this._contextStack, parent2 = stack[stack.length - 1];
@@ -28889,12 +29447,15 @@ ${newlined}
       }
       return next;
     }
+    // ### `_readDataTypeOrLang` reads an _optional_ datatype or language
     _readDataTypeOrLang(token) {
       return this._completeObjectLiteral(token, false);
     }
+    // ### `_readListItemDataTypeOrLang` reads an _optional_ datatype or language in a list
     _readListItemDataTypeOrLang(token) {
       return this._completeObjectLiteral(token, true);
     }
+    // ### `_completeLiteral` completes a literal with an optional datatype or language
     _completeLiteral(token) {
       let literal4 = this._literal(this._literalValue);
       switch (token.type) {
@@ -28913,10 +29474,12 @@ ${newlined}
       }
       return { token, literal: literal4 };
     }
+    // Completes a literal in subject position
     _completeSubjectLiteral(token) {
       this._subject = this._completeLiteral(token).literal;
       return this._readPredicateOrNamedGraph;
     }
+    // Completes a literal in object position
     _completeObjectLiteral(token, listItem) {
       const completed = this._completeLiteral(token);
       if (!completed)
@@ -28931,6 +29494,7 @@ ${newlined}
         return this._readCallback(completed.token);
       }
     }
+    // ### `_readFormulaTail` reads the end of a formula
     _readFormulaTail(token) {
       if (token.type !== "}")
         return this._readPunctuation(token);
@@ -28939,6 +29503,7 @@ ${newlined}
       this._restoreContext("formula", token);
       return this._object === null ? this._readPredicate : this._getContextEndReader();
     }
+    // ### `_readPunctuation` reads punctuation between quads or quad parts
     _readPunctuation(token) {
       let next, graph3 = this._graph;
       const subject = this._subject, inversePredicate = this._inversePredicate;
@@ -28977,6 +29542,7 @@ ${newlined}
       }
       return next;
     }
+    // ### `_readBlankNodePunctuation` reads punctuation in a blank node
     _readBlankNodePunctuation(token) {
       let next;
       switch (token.type) {
@@ -28992,17 +29558,20 @@ ${newlined}
       this._emit(this._subject, this._predicate, this._object, this._graph);
       return next;
     }
+    // ### `_readQuadPunctuation` reads punctuation after a quad
     _readQuadPunctuation(token) {
       if (token.type !== ".")
         return this._error("Expected dot to follow quad", token);
       return this._readInTopContext;
     }
+    // ### `_readPrefix` reads the prefix of a prefix declaration
     _readPrefix(token) {
       if (token.type !== "prefix")
         return this._error("Expected prefix to follow @prefix", token);
       this._prefix = token.value;
       return this._readPrefixIRI;
     }
+    // ### `_readPrefixIRI` reads the IRI of a prefix declaration
     _readPrefixIRI(token) {
       if (token.type !== "IRI")
         return this._error(`Expected IRI to follow prefix "${this._prefix}:"`, token);
@@ -29011,6 +29580,7 @@ ${newlined}
       this._prefixCallback(this._prefix, prefixNode);
       return this._readDeclarationPunctuation;
     }
+    // ### `_readBaseIRI` reads the IRI of a base declaration
     _readBaseIRI(token) {
       const iri = token.type === "IRI" && this._resolveIRI(token.value);
       if (!iri)
@@ -29018,6 +29588,7 @@ ${newlined}
       this._setBase(iri);
       return this._readDeclarationPunctuation;
     }
+    // ### `_readNamedGraphLabel` reads the label of a named graph
     _readNamedGraphLabel(token) {
       switch (token.type) {
         case "IRI":
@@ -29030,12 +29601,14 @@ ${newlined}
           return this._error("Invalid graph label", token);
       }
     }
+    // ### `_readNamedGraphLabel` reads a blank node label of a named graph
     _readNamedGraphBlankLabel(token) {
       if (token.type !== "]")
         return this._error("Invalid graph label", token);
       this._subject = this._blankNode();
       return this._readGraph;
     }
+    // ### `_readDeclarationPunctuation` reads the punctuation of a declaration
     _readDeclarationPunctuation(token) {
       if (this._sparqlStyle) {
         this._sparqlStyle = false;
@@ -29045,6 +29618,7 @@ ${newlined}
         return this._error("Expected declaration to end with a dot", token);
       return this._readInTopContext;
     }
+    // Reads a list of quantified symbols from a @forSome or @forAll statement
     _readQuantifierList(token) {
       let entity;
       switch (token.type) {
@@ -29076,6 +29650,7 @@ ${newlined}
       }
       return this._readQuantifierPunctuation;
     }
+    // Reads punctuation from a @forSome or @forAll statement
     _readQuantifierPunctuation(token) {
       if (token.type === ",")
         return this._readQuantifierList;
@@ -29088,10 +29663,12 @@ ${newlined}
         return this._readCallback(token);
       }
     }
+    // ### `_getPathReader` reads a potential path and then resumes with the given function
     _getPathReader(afterPath) {
       this._afterPath = afterPath;
       return this._readPath;
     }
+    // ### `_readPath` reads a potential path
     _readPath(token) {
       switch (token.type) {
         case "!":
@@ -29108,6 +29685,7 @@ ${newlined}
           return this._afterPath(token);
       }
     }
+    // ### `_readForwardPath` reads a '!' path
     _readForwardPath(token) {
       let subject, predicate;
       const object = this._blankNode();
@@ -29120,6 +29698,7 @@ ${newlined}
       this._emit(subject, predicate, object, this._graph);
       return this._readPath;
     }
+    // ### `_readBackwardPath` reads a '^' path
     _readBackwardPath(token) {
       const subject = this._blankNode();
       let predicate, object;
@@ -29132,6 +29711,7 @@ ${newlined}
       this._emit(subject, predicate, object, this._graph);
       return this._readPath;
     }
+    // ### `_readRDFStarTailOrGraph` reads the graph of a nested RDF* quad or the end of a nested RDF* triple
     _readRDFStarTailOrGraph(token) {
       if (token.type !== ">>") {
         if (this._supportsQuads && this._graph === null && (this._graph = this._readEntity(token)) !== void 0)
@@ -29140,6 +29720,7 @@ ${newlined}
       }
       return this._readRDFStarTail(token);
     }
+    // ### `_readRDFStarTail` reads the end of a nested RDF* triple
     _readRDFStarTail(token) {
       if (token.type !== ">>")
         return this._error(`Expected >> but got ${token.type}`, token);
@@ -29158,6 +29739,7 @@ ${newlined}
         return this._getContextEndReader();
       }
     }
+    // ### `_getContextEndReader` gets the next reader function at the end of a context
     _getContextEndReader() {
       const contextStack = this._contextStack;
       if (!contextStack.length)
@@ -29173,9 +29755,11 @@ ${newlined}
           return this._readRDFStarTailOrGraph;
       }
     }
+    // ### `_emit` sends a quad through the callback
     _emit(subject, predicate, object, graph3) {
       this._callback(null, this._quad(subject, predicate, object, graph3 || this.DEFAULTGRAPH));
     }
+    // ### `_error` emits an error message through the callback
     _error(message2, token) {
       const err = new Error(`${message2} on line ${token.line}.`);
       err.context = {
@@ -29186,9 +29770,12 @@ ${newlined}
       this._callback(err);
       this._callback = noop;
     }
+    // ### `_resolveIRI` resolves an IRI against the base path
     _resolveIRI(iri) {
       return /^[a-z][a-z0-9+.-]*:/i.test(iri) ? iri : this._resolveRelativeIRI(iri);
     }
+    // ### `_resolveRelativeIRI` resolves an IRI against the base path,
+    // assuming that a base path has been set and that the IRI is indeed relative
     _resolveRelativeIRI(iri) {
       if (!iri.length)
         return this._base;
@@ -29203,6 +29790,7 @@ ${newlined}
           return /^[^/:]*:/.test(iri) ? null : this._removeDotSegments(this._basePath + iri);
       }
     }
+    // ### `_removeDotSegments` resolves './' and '../' path segments in an IRI as per RFC3986
     _removeDotSegments(iri) {
       if (!/(^|\/)\.\.?($|[/#?])/.test(iri))
         return iri;
@@ -29250,6 +29838,8 @@ ${newlined}
       }
       return result + iri.substring(segmentStart);
     }
+    // ## Public methods
+    // ### `parse` parses the N3 input and emits each parsed quad through the callback
     parse(input, quadCallback, prefixCallback) {
       this._readCallback = this._readInTopContext;
       this._sparqlStyle = false;
@@ -29319,6 +29909,8 @@ ${newlined}
     "\f": "\\f"
   };
   var SerializedTerm = class extends Term {
+    // Pretty-printed nodes are not equal to any other node
+    // (e.g., [] does not equal [])
     equals() {
       return false;
     }
@@ -29361,12 +29953,16 @@ ${newlined}
         this._writeQuad = this._writeQuadLine;
       }
     }
+    // ## Private methods
+    // ### Whether the current graph is the default graph
     get _inDefaultGraph() {
       return DEFAULTGRAPH2.equals(this._graph);
     }
+    // ### `_write` writes the argument to the output stream
     _write(string, callback) {
       this._outputStream.write(string, "utf8", callback);
     }
+    // ### `_writeQuad` writes the quad to the output stream
     _writeQuad(subject, predicate, object, graph3, done) {
       try {
         if (!graph3.equals(this._graph)) {
@@ -29387,22 +29983,27 @@ ${newlined}
         done && done(error2);
       }
     }
+    // ### `_writeQuadLine` writes the quad to the output stream as a single line
     _writeQuadLine(subject, predicate, object, graph3, done) {
       delete this._prefixMatch;
       this._write(this.quadToString(subject, predicate, object, graph3), done);
     }
+    // ### `quadToString` serializes a quad as a string
     quadToString(subject, predicate, object, graph3) {
       return `${this._encodeSubject(subject)} ${this._encodeIriOrBlank(predicate)} ${this._encodeObject(object)}${graph3 && graph3.value ? ` ${this._encodeIriOrBlank(graph3)} .
 ` : " .\n"}`;
     }
+    // ### `quadsToString` serializes an array of quads as a string
     quadsToString(quads) {
       return quads.map((t) => {
         return this.quadToString(t.subject, t.predicate, t.object, t.graph);
       }).join("");
     }
+    // ### `_encodeSubject` represents a subject
     _encodeSubject(entity) {
       return entity.termType === "Quad" ? this._encodeQuad(entity) : this._encodeIriOrBlank(entity);
     }
+    // ### `_encodeIriOrBlank` represents an IRI or blank node
     _encodeIriOrBlank(entity) {
       if (entity.termType !== "NamedNode") {
         if (this._lists && entity.value in this._lists)
@@ -29417,6 +30018,7 @@ ${newlined}
       const prefixMatch = this._prefixRegex.exec(iri);
       return !prefixMatch ? `<${iri}>` : !prefixMatch[1] ? iri : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
     }
+    // ### `_encodeLiteral` represents a literal
     _encodeLiteral(literal4) {
       let value = literal4.value;
       if (escape2.test(value))
@@ -29450,9 +30052,11 @@ ${newlined}
       }
       return `"${value}"^^${this._encodeIriOrBlank(literal4.datatype)}`;
     }
+    // ### `_encodePredicate` represents a predicate
     _encodePredicate(predicate) {
       return predicate.value === rdf2.type ? "a" : this._encodeIriOrBlank(predicate);
     }
+    // ### `_encodeObject` represents an object
     _encodeObject(object) {
       switch (object.termType) {
         case "Quad":
@@ -29463,12 +30067,15 @@ ${newlined}
           return this._encodeIriOrBlank(object);
       }
     }
+    // ### `_encodeQuad` encodes an RDF* quad
     _encodeQuad({ subject, predicate, object, graph: graph3 }) {
       return `<<${this._encodeSubject(subject)} ${this._encodePredicate(predicate)} ${this._encodeObject(object)}${isDefaultGraph(graph3) ? "" : ` ${this._encodeIriOrBlank(graph3)}`}>>`;
     }
+    // ### `_blockedWrite` replaces `_write` after the writer has been closed
     _blockedWrite() {
       throw new Error("Cannot write because the writer has been closed.");
     }
+    // ### `addQuad` adds the quad to the output stream
     addQuad(subject, predicate, object, graph3, done) {
       if (object === void 0)
         this._writeQuad(subject.subject, subject.predicate, subject.object, subject.graph, predicate);
@@ -29477,15 +30084,18 @@ ${newlined}
       else
         this._writeQuad(subject, predicate, object, graph3 || DEFAULTGRAPH2, done);
     }
+    // ### `addQuads` adds the quads to the output stream
     addQuads(quads) {
       for (let i = 0; i < quads.length; i++)
         this.addQuad(quads[i]);
     }
+    // ### `addPrefix` adds the prefix to the output stream
     addPrefix(prefix, iri, done) {
       const prefixes = {};
       prefixes[prefix] = iri;
       this.addPrefixes(prefixes, done);
     }
+    // ### `addPrefixes` adds the prefixes to the output stream
     addPrefixes(prefixes, done) {
       if (!this._prefixIRIs)
         return done && done();
@@ -29514,6 +30124,7 @@ ${newlined}
       }
       this._write(hasPrefixes ? "\n" : "", done);
     }
+    // ### `blank` creates a blank node with the given content
     blank(predicate, object) {
       let children = predicate, child, length;
       if (predicate === void 0)
@@ -29544,12 +30155,14 @@ ${newlined}
 ]`);
       }
     }
+    // ### `list` creates a list node with the given content
     list(elements) {
       const length = elements && elements.length || 0, contents = new Array(length);
       for (let i = 0; i < length; i++)
         contents[i] = this._encodeObject(elements[i]);
       return new SerializedTerm(`(${contents.join(" ")})`);
     }
+    // ### `end` signals the end of the output stream
     end(done) {
       if (this._subject !== null) {
         this._write(this._inDefaultGraph ? ".\n" : "\n}\n");
@@ -29738,11 +30351,19 @@ ${newlined}
       set: function set(g) {
         this.graph = g;
       }
+      /**
+       * Checks whether two statements are the same
+       * @param other - The other statement
+       */
     }, {
       key: "equals",
       value: function equals2(other) {
         return other.subject.equals(this.subject) && other.predicate.equals(this.predicate) && other.object.equals(this.object) && other.graph.equals(this.graph);
       }
+      /**
+       * Creates a statement with the bindings substituted
+       * @param bindings The bindings
+       */
     }, {
       key: "substitute",
       value: function substitute(bindings) {
@@ -29750,6 +30371,7 @@ ${newlined}
         console.log("@@@ statement substitute:" + y);
         return y;
       }
+      /** Creates a canonical string representation of this statement. */
     }, {
       key: "toCanonical",
       value: function toCanonical() {
@@ -29759,16 +30381,19 @@ ${newlined}
         }
         return terms.join(" ") + " .";
       }
+      /** Creates a n-triples string representation of this statement */
     }, {
       key: "toNT",
       value: function toNT() {
         return [this.subject.toNT(), this.predicate.toNT(), this.object.toNT()].join(" ") + " .";
       }
+      /** Creates a n-quads string representation of this statement */
     }, {
       key: "toNQ",
       value: function toNQ2() {
         return [this.subject.toNT(), this.predicate.toNT(), this.object.toNT(), isDefaultGraph2(this.graph) ? "" : this.graph.toNT()].join(" ") + " .";
       }
+      /** Creates a string representation of this statement */
     }, {
       key: "toString",
       value: function toString() {
@@ -30046,12 +30671,19 @@ ${newlined}
   var _defaultGraph = new DefaultGraph2();
   var CanonicalDataFactory = {
     supports: (_supports = {}, _defineProperty(_supports, Feature.collections, false), _defineProperty(_supports, Feature.defaultGraphType, false), _defineProperty(_supports, Feature.equalsMethod, true), _defineProperty(_supports, Feature.identity, false), _defineProperty(_supports, Feature.id, true), _defineProperty(_supports, Feature.reversibleId, false), _defineProperty(_supports, Feature.variableType, true), _supports),
+    /**
+     * Creates a new blank node
+     * @param value - The blank node's identifier
+     */
     blankNode: function blankNode2(value) {
       return new BlankNode(value);
     },
     defaultGraph: function defaultGraph3() {
       return _defaultGraph;
     },
+    /**
+     * Compares to (rdf) objects for equality.
+     */
     equals: function equals(a, b) {
       if (a === b || !a || !b) {
         return true;
@@ -30067,6 +30699,14 @@ ${newlined}
       }
       return false;
     },
+    /**
+     * Generates a uniquely identifiably *idempotent* string for the given {term}.
+     *
+     * Equivalent to [[Term.hashString]]
+     *
+     * @example Use this to associate data with a term in an object
+     *   { obj[id(term)] = "myData" }
+     */
     id: function id(term2) {
       if (!term2) {
         return "undefined";
@@ -30090,6 +30730,11 @@ ${newlined}
     isQuad: function isQuad2(obj) {
       return obj instanceof Statement;
     },
+    /**
+     * Creates a new literal node. Does some JS literal parsing for ease of use.
+     * @param value - The lexical value
+     * @param languageOrDatatype - Either the language or the datatype
+     */
     literal: function literal2(value, languageOrDatatype) {
       if (typeof value !== "string" && !languageOrDatatype) {
         return Literal.fromValue(value);
@@ -30105,18 +30750,37 @@ ${newlined}
         return new Literal(strValue, null, languageOrDatatype);
       }
     },
+    /**
+     * Creates a new named node
+     * @param value - The new named node
+     */
     namedNode: function namedNode2(value) {
       return new NamedNode(value);
     },
+    /**
+     * Creates a new statement
+     * @param subject - The subject
+     * @param predicate - The predicate
+     * @param object - The object
+     * @param graph - The containing graph
+     */
     quad: function quad3(subject, predicate, object, graph3) {
       return new Statement(subject, predicate, object, graph3 || _defaultGraph);
     },
+    /**
+     * Creates a new statement
+     * @param subject - The subject
+     * @param predicate - The predicate
+     * @param object - The object
+     * @param graph - The containing graph
+     */
     triple: function triple(subject, predicate, object, graph3) {
       return this.quad(subject, predicate, object, graph3);
     },
     quadToNQ: function quadToNQ(q) {
       return "".concat(this.termToNQ(q.subject), " ").concat(this.termToNQ(q.predicate), " ").concat(this.termToNQ(q.object), " ").concat(this.termToNQ(q.graph), " .");
     },
+    /** Stringify a {term} to n-quads serialization. */
     termToNQ: function termToNQ(term2) {
       var _this = this;
       switch (term2.termType) {
@@ -30139,12 +30803,17 @@ ${newlined}
           throw new Error("Can't serialize nonstandard term type (was '".concat(term2.termType, "')"));
       }
     },
+    /** Convert an rdf object (term or quad) to n-quads serialization. */
     toNQ: function toNQ(term2) {
       if (this.isQuad(term2)) {
         return this.quadToNQ(term2);
       }
       return this.termToNQ(term2);
     },
+    /**
+     * Creates a new variable
+     * @param name - The name for the variable
+     */
     variable: function variable2(name) {
       return new Variable2(name);
     }
@@ -30446,6 +31115,12 @@ ${newlined}
         }
         return this.store.fromNT(s);
       }
+      /**
+       * Defines a set of [prefix, namespace] pairs to be used by this Serializer instance.
+       * Overrides previous prefixes if any
+       * @param namespaces
+       * @return {Serializer}
+       */
     }, {
       key: "setNamespaces",
       value: function setNamespaces(namespaces) {
@@ -30454,6 +31129,11 @@ ${newlined}
         }
         return this;
       }
+      /**
+       * Defines a namespace prefix, overriding any existing prefix for that URI
+       * @param prefix
+       * @param uri
+       */
     }, {
       key: "setPrefix",
       value: function setPrefix(prefix, uri) {
@@ -30470,6 +31150,11 @@ ${newlined}
         this.prefixes[uri] = prefix;
         this.namespaces[prefix] = uri;
       }
+      /* Accumulate Namespaces
+      **
+      ** These are only hints.  If two overlap, only one gets used
+      ** There is therefore no guarantee in general.
+      */
     }, {
       key: "suggestPrefix",
       value: function suggestPrefix(prefix, uri) {
@@ -30484,6 +31169,7 @@ ${newlined}
         this.prefixes[uri] = prefix;
         this.namespaces[prefix] = uri;
       }
+      // Takes a namespace -> prefix map
     }, {
       key: "suggestNamespaces",
       value: function suggestNamespaces(namespaces) {
@@ -30507,6 +31193,7 @@ ${newlined}
           }
         }
       }
+      // Make up an unused prefix for a random namespace
     }, {
       key: "makeUpPrefix",
       value: function makeUpPrefix(uri) {
@@ -30609,6 +31296,7 @@ ${newlined}
           "incoming": incoming
         };
       }
+      // //////////////////////////////////////////////////////
     }, {
       key: "toN3",
       value: function toN3(f) {
@@ -30747,7 +31435,8 @@ ${newlined}
                   continue;
                 }
               }
-              if (lastLength < indent * level + 4 || lastLength + branch.length + 1 < width && ";.".indexOf(str[str.length - 2]) < 0) {
+              if (lastLength < indent * level + 4 || // if new line not necessary
+              lastLength + branch.length + 1 < width && ";.".indexOf(str[str.length - 2]) < 0) {
                 str = str.slice(0, -1) + " " + branch + "\n";
                 lastLength += branch.length + 1;
               } else {
@@ -30855,6 +31544,8 @@ ${newlined}
         var tree = statementListToTree(sts);
         return prefixDirectives() + treeToString(tree);
       }
+      // //////////////////////////////////////////// Atomic Terms
+      //  Deal with term level things and nesting with no bnode structure
     }, {
       key: "atomicTermToN3",
       value: function atomicTermToN3(expr, stats) {
@@ -30902,6 +31593,7 @@ ${newlined}
             throw new Error("Internal: atomicTermToN3 cannot handle " + expr + " of termType: " + expr.termType);
         }
       }
+      //  stringToN3:  String escaping for N3
     }, {
       key: "stringToN3",
       value: function stringToN3(str, flags) {
@@ -30911,7 +31603,10 @@ ${newlined}
         var i, j, k;
         var delim;
         var forbidden;
-        if (str.length > 20 && str.slice(-1) !== '"' && flags.indexOf("n") < 0 && (str.indexOf("\n") > 0 || str.indexOf('"') > 0)) {
+        if (str.length > 20 && // Long enough to make sense
+        str.slice(-1) !== '"' && // corner case'
+        flags.indexOf("n") < 0 && // Force single line
+        (str.indexOf("\n") > 0 || str.indexOf('"') > 0)) {
           delim = '"""';
           forbidden = this.forbidden3;
         } else {
@@ -30944,6 +31639,7 @@ ${newlined}
         }
         return delim + res + str.slice(i) + delim;
       }
+      //  A single symbol, either in  <> or namespace notation
     }, {
       key: "symbolToN3",
       value: function symbolToN3(x) {
@@ -30952,7 +31648,8 @@ ${newlined}
         if (j < 0 && this.flags.indexOf("/") < 0) {
           j = uri.lastIndexOf("/");
         }
-        if (j >= 0 && this.flags.indexOf("p") < 0 && (uri.indexOf("http") === 0 || uri.indexOf("ws") === 0 || uri.indexOf("file") === 0)) {
+        if (j >= 0 && this.flags.indexOf("p") < 0 && // Can split at namespace but only if http[s]: URI or file: or ws[s] (why not others?)
+        (uri.indexOf("http") === 0 || uri.indexOf("ws") === 0 || uri.indexOf("file") === 0)) {
           var canSplit = true;
           for (var k = j + 1; k < uri.length; k++) {
             if (this._notNameChars.indexOf(uri[k]) >= 0) {
@@ -30980,6 +31677,9 @@ ${newlined}
         }
         return this.explicitURI(uri);
       }
+      // /////////////////////////// Quad store serialization
+      // @para. write  - a function taking a single string to be output
+      //
     }, {
       key: "writeStore",
       value: function writeStore(write) {
@@ -31008,6 +31708,7 @@ ${newlined}
         });
         write(this.statementsToN3(metadata));
       }
+      // ////////////////////////////////////////////// XML serialization
     }, {
       key: "statementsToXML",
       value: function statementsToXML(sts) {
@@ -31246,6 +31947,7 @@ ${newlined}
         var tree2 = [str, tree, "</rdf:RDF>"];
         return XMLtreeToString(tree2, -1);
       }
+      // End @@ body
     }]);
     return Serializer2;
   }();
@@ -31510,16 +32212,27 @@ ${newlined}
         }
         return this.statements.push(this.rdfFactory.quad(subject, predicate, object, graph3));
       }
+      /** Add a statment object
+       * @param {Statement} statement - An existing constructed statement to add
+       */
     }, {
       key: "addStatement",
       value: function addStatement(statement) {
         return this.add(statement);
       }
+      /**
+       * Shortcut for adding blankNodes
+       * @param [id]
+       */
     }, {
       key: "bnode",
       value: function bnode(id3) {
         return this.rdfFactory.blankNode(id3);
       }
+      /**
+       * Adds all the statements to this formula
+       * @param statements - A collection of statements
+       */
     }, {
       key: "addAll",
       value: function addAll(statements) {
@@ -31528,6 +32241,18 @@ ${newlined}
           _this3.add(quad5.subject, quad5.predicate, quad5.object, quad5.graph);
         });
       }
+      /** Follow link from one node, using one wildcard, looking for one
+      *
+      * For example, any(me, knows, null, profile)  - a person I know accoring to my profile .
+      * any(me, knows, null, null)  - a person I know accoring to anything in store .
+      * any(null, knows, me, null)  - a person who know me accoring to anything in store .
+      *
+      * @param s - A node to search for as subject, or if null, a wildcard
+      * @param p - A node to search for as predicate, or if null, a wildcard
+      * @param o - A node to search for as object, or if null, a wildcard
+      * @param g - A node to search for as graph, or if null, a wildcard
+      * @returns A node which match the wildcard position, or null
+      */
     }, {
       key: "any",
       value: function any(s, p, o, g) {
@@ -31543,18 +32268,35 @@ ${newlined}
         }
         return null;
       }
+      /**
+       * Gets the value of a node that matches the specified pattern
+       * @param s The subject
+       * @param p The predicate
+       * @param o The object
+       * @param g The graph that contains the statement
+       */
     }, {
       key: "anyValue",
       value: function anyValue(s, p, o, g) {
         var y = this.any(s, p, o, g);
         return y ? y.value : void 0;
       }
+      /**
+       * Gets the first JavaScript object equivalent to a node based on the specified pattern
+       * @param s The subject
+       * @param p The predicate
+       * @param o The object
+       * @param g The graph that contains the statement
+       */
     }, {
       key: "anyJS",
       value: function anyJS(s, p, o, g) {
         var y = this.any(s, p, o, g);
         return y ? Node2.toJS(y) : void 0;
       }
+      /**
+       * Gets the first statement that matches the specified pattern
+       */
     }, {
       key: "anyStatementMatching",
       value: function anyStatementMatching(s, p, o, g) {
@@ -31564,11 +32306,27 @@ ${newlined}
         }
         return x[0];
       }
+      /**
+       * Returns a unique index-safe identifier for the given term.
+       *
+       * Falls back to the rdflib hashString implementation if the given factory doesn't support id.
+       */
     }, {
       key: "id",
       value: function id3(term2) {
         return this.rdfFactory.id(term2);
       }
+      /**
+       * Search the Store
+       * This is really a teaching method as to do this properly you would use IndexedFormula
+       *
+       * @param s - A node to search for as subject, or if null, a wildcard
+       * @param p - A node to search for as predicate, or if null, a wildcard
+       * @param o - A node to search for as object, or if null, a wildcard
+       * @param g - A node to search for as graph, or if null, a wildcard
+       * @param justOne - flag - stop when found one rather than get all of them?
+       * @returns {Array<Node>} - An array of nodes which match the wildcard position
+       */
     }, {
       key: "statementsMatching",
       value: function statementsMatching(s, p, o, g, justOne) {
@@ -31580,6 +32338,13 @@ ${newlined}
         }
         return sts;
       }
+      /**
+       * Finds the types in the list which have no *stored* subtypes
+       * These are a set of classes which provide by themselves complete
+       * information -- the other classes are redundant for those who
+       * know the class DAG.
+       * @param types A map of the types
+       */
     }, {
       key: "bottomTypeURIs",
       value: function bottomTypeURIs(types2) {
@@ -31613,11 +32378,24 @@ ${newlined}
         }
         return bots;
       }
+      /** Creates a new collection */
     }, {
       key: "collection",
       value: function collection2() {
         return new Collection();
       }
+      /** Follow links from one node, using one wildcard.
+      *
+      * For example, each(me, knows, null, profile)  - people I know accoring to my profile .
+      * each(me, knows, null, null)  - people I know accoring to anything in store .
+      * each(null, knows, me, null)  - people who know me accoring to anything in store .
+      *
+      * @param s - A node to search for as subject, or if null, a wildcard
+      * @param p - A node to search for as predicate, or if null, a wildcard
+      * @param o - A node to search for as object, or if null, a wildcard
+      * @param g - A node to search for as graph, or if null, a wildcard
+      * @returns {Array<Node>} - An array of nodes which match the wildcard position
+      */
     }, {
       key: "each",
       value: function each2(s, p, o, g) {
@@ -31642,6 +32420,10 @@ ${newlined}
         }
         return results;
       }
+      /**
+       * Test whether this formula is equals to {other}
+       * @param other - The other formula
+       */
     }, {
       key: "equals",
       value: function equals2(other) {
@@ -31650,6 +32432,15 @@ ${newlined}
         }
         return this.hashString() === other.hashString();
       }
+      /**
+       * For thisClass or any subclass, anything which has it is its type
+       * or is the object of something which has the type as its range, or subject
+       * of something which has the type as its domain
+       * We don't bother doing subproperty (yet?)as it doesn't seeem to be used
+       * much.
+       * Get all the Classes of which we can RDFS-infer the subject is a member
+       * @return a hash of URIs
+       */
     }, {
       key: "findMembersNT",
       value: function findMembersNT(thisClass) {
@@ -31700,11 +32491,27 @@ ${newlined}
         }
         return members;
       }
+      /**
+       * For thisClass or any subclass, anything which has it is its type
+       * or is the object of something which has the type as its range, or subject
+       * of something which has the type as its domain
+       * We don't bother doing subproperty (yet?)as it doesn't seeem to be used
+       * much.
+       * Get all the Classes of which we can RDFS-infer the subject is a member
+       * @param subject - A named node
+       */
     }, {
       key: "findMemberURIs",
       value: function findMemberURIs(subject) {
         return this.NTtoURI(this.findMembersNT(subject));
       }
+      /**
+       * Get all the Classes of which we can RDFS-infer the subject is a superclass
+       * Returns a hash table where key is NT of type and value is statement why we
+       * think so.
+       * Does NOT return terms, returns URI strings.
+       * We use NT representations in this version because they handle blank nodes.
+       */
     }, {
       key: "findSubClassesNT",
       value: function findSubClassesNT(subject) {
@@ -31712,6 +32519,14 @@ ${newlined}
         types2[subject.toNT()] = true;
         return this.transitiveClosure(types2, this.rdfFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf"), true);
       }
+      /**
+       * Get all the Classes of which we can RDFS-infer the subject is a subclass
+       * @param {RDFlibNamedNode} subject - The thing whose classes are to be found
+       * @returns a hash table where key is NT of type and value is statement why we
+       * think so.
+       * Does NOT return terms, returns URI strings.
+       * We use NT representations in this version because they handle blank nodes.
+       */
     }, {
       key: "findSuperClassesNT",
       value: function findSuperClassesNT(subject) {
@@ -31719,6 +32534,15 @@ ${newlined}
         types2[subject.toNT()] = true;
         return this.transitiveClosure(types2, this.rdfFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf"), false);
       }
+      /**
+       * Get all the Classes of which we can RDFS-infer the subject is a member
+       * todo: This will loop is there is a class subclass loop (Sublass loops are
+       * not illegal)
+       * @param {RDFlibNamedNode} subject - The thing whose classes are to be found
+       * @returns a hash table where key is NT of type and value is statement why we think so.
+       * Does NOT return terms, returns URI strings.
+       * We use NT representations in this version because they handle blank nodes.
+       */
     }, {
       key: "findTypesNT",
       value: function findTypesNT(subject) {
@@ -31757,11 +32581,27 @@ ${newlined}
         }
         return this.transitiveClosure(types2, this.rdfFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf"), false);
       }
+      /**
+       * Get all the Classes of which we can RDFS-infer the subject is a member
+       * todo: This will loop is there is a class subclass loop (Sublass loops are
+       * not illegal)
+       * Returns a hash table where key is NT of type and value is statement why we
+       * think so.
+       * Does NOT return terms, returns URI strings.
+       * We use NT representations in this version because they handle blank nodes.
+       * @param subject - A subject node
+       */
     }, {
       key: "findTypeURIs",
       value: function findTypeURIs(subject) {
         return this.NTtoURI(this.findTypesNT(subject));
       }
+      /** Trace statements which connect directly, or through bnodes
+       *
+       * @param subject - The node to start looking for statments
+       * @param doc - The document to be searched, or null to search all documents
+       * @returns an array of statements, duplicate statements are suppresssed.
+       */
     }, {
       key: "connectedStatements",
       value: function connectedStatements(subject, doc, excludePredicateURIs) {
@@ -31799,11 +32639,22 @@ ${newlined}
         }
         return result;
       }
+      /**
+       * Creates a new empty formula
+       *
+       * @param _features - Not applicable, but necessary for typing to pass
+       */
     }, {
       key: "formula",
       value: function formula2(_features) {
         return new Formula2();
       }
+      /**
+       * Transforms an NTriples string format into a Node.
+       * The blank node bit should not be used on program-external values; designed
+       * for internal work such as storing a blank node id in an HTML attribute.
+       * This will only parse the strings generated by the various toNT() methods.
+       */
     }, {
       key: "fromNT",
       value: function fromNT(str) {
@@ -31836,6 +32687,7 @@ ${newlined}
         }
         throw new Error("Can't convert from NT: " + str);
       }
+      /** Returns true if this formula holds the specified statement(s) */
     }, {
       key: "holds",
       value: function holds(s, p, o, g) {
@@ -31860,11 +32712,20 @@ ${newlined}
         var st3 = this.anyStatementMatching(s, p, o, g);
         return st3 != null;
       }
+      /**
+       * Returns true if this formula holds the specified {statement}
+       */
     }, {
       key: "holdsStatement",
       value: function holdsStatement(statement) {
         return this.holds(statement.subject, statement.predicate, statement.object, statement.graph);
       }
+      /**
+       * Used by the n3parser to generate list elements
+       * @param values - The values of the collection
+       * @param context - The store
+       * @return {BlankNode|Collection} - The term for the statement
+       */
     }, {
       key: "list",
       value: function list(values, context) {
@@ -31881,6 +32742,12 @@ ${newlined}
           return node;
         }
       }
+      /**
+       * Transform a collection of NTriple URIs into their URI strings
+       * @param t - Some iterable collection of NTriple URI strings
+       * @return A collection of the URIs as strings
+       * todo: explain why it is important to go through NT
+       */
     }, {
       key: "NTtoURI",
       value: function NTtoURI(t) {
@@ -31896,11 +32763,22 @@ ${newlined}
         }
         return uris;
       }
+      /**
+       * Serializes this formula
+       * @param base - The base string
+       * @param contentType - The content type of the syntax to use
+       * @param provenance - The provenance URI
+       * @param options  - options to pass to the serializer, as defined in serialize method
+       */
     }, {
       key: "serialize",
       value: function serialize2(base, contentType, provenance, options) {
         return serialize(provenance, this, base, contentType, void 0, options);
       }
+      /**
+       * Creates a new formula with the substituting bindings applied
+       * @param bindings - The bindings to substitute
+       */
     }, {
       key: "substitute",
       value: function substitute(bindings) {
@@ -31921,6 +32799,13 @@ ${newlined}
         }
         return this.rdfFactory.namedNode(uri);
       }
+      /**
+       * Gets the node matching the specified pattern. Throws when no match could be made.
+       * @param s - The subject
+       * @param p - The predicate
+       * @param o - The object
+       * @param g - The graph that contains the statement
+       */
     }, {
       key: "the",
       value: function the(s, p, o, g) {
@@ -31930,6 +32815,14 @@ ${newlined}
         }
         return x;
       }
+      /**
+       * RDFS Inference
+       * These are hand-written implementations of a backward-chaining reasoner
+       * over the RDFS axioms.
+       * @param seeds - A hash of NTs of classes to start with
+       * @param predicate - The property to trace though
+       * @param inverse - Trace inverse direction
+       */
     }, {
       key: "transitiveClosure",
       value: function transitiveClosure(seeds, predicate, inverse) {
@@ -31964,6 +32857,12 @@ ${newlined}
           delete agenda[t];
         }
       }
+      /**
+       * Finds the types in the list which have no *stored* supertypes
+       * We exclude the universal class, owl:Things and rdf:Resource, as it is
+       * information-free.
+       * @param types - The types
+       */
     }, {
       key: "topTypeURIs",
       value: function topTypeURIs(types2) {
@@ -32001,16 +32900,30 @@ ${newlined}
         }
         return tops;
       }
+      /**
+       * Serializes this formula to a string
+       */
     }, {
       key: "toString",
       value: function toString() {
         return "{" + this.statements.join("\n") + "}";
       }
+      /**
+       * Gets a new variable
+       * @param name - The variable's name
+       */
     }, {
       key: "variable",
       value: function variable4(name) {
         return new Variable2(name);
       }
+      /**
+       * Gets the number of statements in this formula that matches the specified pattern
+       * @param s - The subject
+       * @param p - The predicate
+       * @param o - The object
+       * @param g - The graph that contains the statement
+       */
     }, {
       key: "whether",
       value: function whether(s, p, o, g) {
@@ -32316,6 +33229,7 @@ ${newlined}
               bindingsSoFar,
               level,
               fetcher4,
+              // match not match2 to look up any others necessary.
               localCallback,
               branch
             );
@@ -32603,7 +33517,13 @@ ${newlined}
       _this.whyIndex = [];
       _this.index = [_this.subjectIndex, _this.predicateIndex, _this.objectIndex, _this.whyIndex];
       _this.namespaces = {};
-      _this.features = features || [];
+      _this.features = features || [
+        // By default, devs do not expect these features.
+        // See https://github.com/linkeddata/rdflib.js/issues/458
+        //      'sameAs',
+        //      'InverseFunctionalProperty',
+        //      'FunctionalProperty',
+      ];
       _this.rdfArrayRemove = opts.rdfArrayRemove || RDFArrayRemove;
       if (opts.dataCallback) {
         _this.dataCallbacks = [opts.dataCallback];
@@ -32613,14 +33533,24 @@ ${newlined}
     }
     _createClass(IndexedFormula5, [{
       key: "substitute",
-      value: function substitute(bindings) {
-        var statementsCopy = this.statements.map(function(ea) {
-          return ea.substitute(bindings);
-        });
-        var y = new IndexedFormula5();
-        y.add(statementsCopy);
-        return y;
-      }
+      value: (
+        /**
+         * Gets this graph with the bindings substituted
+         * @param bindings The bindings
+         */
+        function substitute(bindings) {
+          var statementsCopy = this.statements.map(function(ea) {
+            return ea.substitute(bindings);
+          });
+          var y = new IndexedFormula5();
+          y.add(statementsCopy);
+          return y;
+        }
+      )
+      /**
+       * Add a callback which will be triggered after a statement has been added to the store.
+       * @param cb
+       */
     }, {
       key: "addDataCallback",
       value: function addDataCallback(cb) {
@@ -32629,6 +33559,13 @@ ${newlined}
         }
         this.dataCallbacks.push(cb);
       }
+      /**
+       * Apply a set of statements to be deleted and to be inserted
+       *
+       * @param patch - The set of statements to be deleted and to be inserted
+       * @param target - The name of the document to patch
+       * @param patchCallback - Callback to be called when patching is complete
+       */
     }, {
       key: "applyPatch",
       value: function applyPatch(patch, target, patchCallback) {
@@ -32694,6 +33631,11 @@ ${newlined}
           doPatch(patchCallback);
         }
       }
+      /**
+       * N3 allows for declaring blank nodes, this function enables that support
+       *
+       * @param x The blank node to be declared, supported in N3
+       */
     }, {
       key: "declareExistential",
       value: function declareExistential(x) {
@@ -32702,6 +33644,9 @@ ${newlined}
         this._existentialVariables.push(x);
         return x;
       }
+      /**
+       * @param features
+       */
     }, {
       key: "initPropertyActions",
       value: function initPropertyActions(features) {
@@ -32723,12 +33668,23 @@ ${newlined}
           }];
         }
       }
+      /** @deprecated Use {add} instead */
     }, {
       key: "addStatement",
       value: function addStatement(st3) {
         this.add(st3.subject, st3.predicate, st3.object, st3.graph);
         return this.statements.length;
       }
+      /**
+       * Adds a triple (quad) to the store.
+       *
+       * @param subj - The thing about which the fact a relationship is asserted.
+       *        Also accepts a statement or an array of Statements.
+       * @param pred - The relationship which is asserted
+       * @param obj - The object of the relationship, e.g. another thing or a value. If passed a string, this will become a literal.
+       * @param why - The document in which the triple (S,P,O) was or will be stored on the web
+       * @returns The statement added to the store, or the store
+       */
     }, {
       key: "add",
       value: function add(subj, pred, obj, why) {
@@ -32808,6 +33764,10 @@ ${newlined}
         }
         return st3;
       }
+      /**
+       * Returns the symbol with canonical URI as smushed
+       * @param term - An RDF node
+       */
     }, {
       key: "canon",
       value: function canon(term2) {
@@ -32839,6 +33799,9 @@ ${newlined}
             throw new Error("Term Type not recognized for canonization: ".concat(term2.termType));
         }
       }
+      /**
+       * Checks this formula for consistency
+       */
     }, {
       key: "check",
       value: function check2() {
@@ -32852,6 +33815,11 @@ ${newlined}
           }
         }
       }
+      /**
+       * Checks a list of statements for consistency
+       * @param sts - The list of statements to check
+       * @param from - An index with the array ['subject', 'predicate', 'object', 'why']
+       */
     }, {
       key: "checkStatementList",
       value: function checkStatementList(sts, from) {
@@ -32885,6 +33853,9 @@ ${newlined}
           }
         }
       }
+      /**
+       * Closes this formula (and return it)
+       */
     }, {
       key: "close",
       value: function close() {
@@ -32910,6 +33881,13 @@ ${newlined}
         }
         return 0;
       }
+      /**
+       * replaces @template with @target and add appropriate triples
+       * removes no triples by default and is a one-direction replication
+       * @param template node to copy
+       * @param target node to copy to
+       * @param flags Whether or not to do a two-directional copy and/or delete triples
+       */
     }, {
       key: "copyTo",
       value: function copyTo(template, target, flags) {
@@ -32935,6 +33913,12 @@ ${newlined}
           }
         }
       }
+      /**
+       * Simplify graph in store when we realize two identifiers are equivalent
+       * We replace the bigger with the smaller.
+       * @param u1in The first node
+       * @param u2in The second node
+       */
     }, {
       key: "equate",
       value: function equate(u1in, u2in) {
@@ -32950,27 +33934,59 @@ ${newlined}
           return this.replaceWith(u1, u2);
         }
       }
+      /**
+       * Creates a new empty indexed formula
+       * Only applicable for IndexedFormula, but TypeScript won't allow a subclass to override a property
+       * @param features The list of features
+       */
     }, {
       key: "formula",
       value: function formula2(features) {
         return new IndexedFormula5(features);
       }
+      /**
+       * Returns the number of statements contained in this IndexedFormula.
+       * (Getter proxy to this.statements).
+       * Usage:
+       *    ```
+       *    var kb = rdf.graph()
+       *    kb.length  // -> 0
+       *    ```
+       * @returns {Number}
+       */
     }, {
       key: "length",
       get: function get() {
         return this.statements.length;
       }
+      /**
+       * Returns any quads matching the given arguments.
+       * Standard RDFJS spec method for Source objects, implemented as an
+       * alias to `statementsMatching()`
+       * @param subject The subject
+       * @param predicate The predicate
+       * @param object The object
+       * @param graph The graph that contains the statement
+       */
     }, {
       key: "match",
       value: function match(subject, predicate, object, graph3) {
         return this.statementsMatching(node_default.fromValue(subject), node_default.fromValue(predicate), node_default.fromValue(object), node_default.fromValue(graph3));
       }
+      /**
+       * Find out whether a given URI is used as symbol in the formula
+       * @param uri The URI to look for
+       */
     }, {
       key: "mentionsURI",
       value: function mentionsURI(uri) {
         var hash = "<" + uri + ">";
         return !!this.subjectIndex[hash] || !!this.objectIndex[hash] || !!this.predicateIndex[hash];
       }
+      /**
+       * Existentials are BNodes - something exists without naming
+       * @param uri An URI
+       */
     }, {
       key: "newExistential",
       value: function newExistential(uri) {
@@ -32979,6 +33995,11 @@ ${newlined}
         var x = this.sym(uri);
         return this.declareExistential(x);
       }
+      /**
+       * Adds a new property action
+       * @param pred the predicate that the function should be triggered on
+       * @param action the function that should trigger
+       */
     }, {
       key: "newPropertyAction",
       value: function newPropertyAction(pred, action) {
@@ -32994,6 +34015,11 @@ ${newlined}
         }
         return done;
       }
+      /**
+       * Creates a new universal node
+       * Universals are Variables
+       * @param uri An URI
+       */
     }, {
       key: "newUniversal",
       value: function newUniversal(uri) {
@@ -33003,11 +34029,17 @@ ${newlined}
         this._universalVariables.push(x);
         return x;
       }
+      // convenience function used by N3 parser
     }, {
       key: "variable",
       value: function variable4(name) {
         return new Variable2(name);
       }
+      /**
+       * Find an unused id for a file being edited: return a symbol
+       * (Note: Slow iff a lot of them -- could be O(log(k)) )
+       * @param doc A document named node
+       */
     }, {
       key: "nextSymbol",
       value: function nextSymbol(doc) {
@@ -33017,11 +34049,24 @@ ${newlined}
             return this.sym(uri);
         }
       }
+      /**
+       * Query this store asynchronously, return bindings in callback
+       *
+       * @param myQuery The query to be run
+       * @param callback Function to call when bindings
+       * @param Fetcher | null  If you want the query to do link following
+       * @param onDone OBSOLETE - do not use this // @@ Why not ?? Called when query complete
+       */
     }, {
       key: "query",
       value: function query(myQuery, callback, fetcher3, onDone) {
         return indexedFormulaQuery.call(this, myQuery, callback, fetcher3, onDone);
       }
+      /**
+       * Query this store synchronously and return bindings
+       *
+       * @param myQuery The query to be run
+       */
     }, {
       key: "querySync",
       value: function querySync(myQuery) {
@@ -33040,6 +34085,10 @@ ${newlined}
         }
         return results;
       }
+      /**
+       * Removes one or multiple statement(s) from this formula
+       * @param st - A Statement or array of Statements to remove
+       */
     }, {
       key: "remove",
       value: function remove(st3) {
@@ -33059,6 +34108,10 @@ ${newlined}
         this.removeStatement(sts[0]);
         return this;
       }
+      /**
+       * Removes all statements in a doc
+       * @param doc - The document / graph
+       */
     }, {
       key: "removeDocument",
       value: function removeDocument(doc) {
@@ -33068,6 +34121,14 @@ ${newlined}
         }
         return this;
       }
+      /**
+       * Remove all statements matching args (within limit) *
+       * @param subj The subject
+       * @param pred The predicate
+       * @param obj The object
+       * @param why The graph that contains the statement
+       * @param limit The number of statements to remove
+       */
     }, {
       key: "removeMany",
       value: function removeMany(subj, pred, obj, why, limit) {
@@ -33082,12 +34143,26 @@ ${newlined}
           this.remove(statements[i]);
         }
       }
+      /**
+       * Remove all matching statements
+       * @param subject The subject
+       * @param predicate The predicate
+       * @param object The object
+       * @param graph The graph that contains the statement
+       */
     }, {
       key: "removeMatches",
       value: function removeMatches(subject, predicate, object, graph3) {
         this.removeMany(subject, predicate, object, graph3);
         return this;
       }
+      /**
+       * Remove a particular statement object from the store
+       *
+       * @param st - a statement which is already in the store and indexed.
+       *        Make sure you only use this for these.
+       *        Otherwise, you should use remove() above.
+       */
     }, {
       key: "removeStatement",
       value: function removeStatement(st3) {
@@ -33103,6 +34178,10 @@ ${newlined}
         this.rdfArrayRemove(this.statements, st3);
         return this;
       }
+      /**
+       * Removes statements
+       * @param sts The statements to remove
+       */
     }, {
       key: "removeStatements",
       value: function removeStatements(sts) {
@@ -33111,6 +34190,9 @@ ${newlined}
         }
         return this;
       }
+      /**
+       * Replace big with small, obsoleted with obsoleting.
+       */
     }, {
       key: "replaceWith",
       value: function replaceWith(big, small) {
@@ -33153,6 +34235,10 @@ ${newlined}
         moveIndex(this.propertyActions);
         return true;
       }
+      /**
+       * Return all equivalent URIs by which this is known
+       * @param x A named node
+       */
     }, {
       key: "allAliases",
       value: function allAliases(x) {
@@ -33160,6 +34246,11 @@ ${newlined}
         a.push(this.canon(x));
         return a;
       }
+      /**
+       * Compare by canonical URI as smushed
+       * @param x A named node
+       * @param y Another named node
+       */
     }, {
       key: "sameThings",
       value: function sameThings(x, y) {
@@ -33189,6 +34280,16 @@ ${newlined}
         }
         this.namespaces[prefix] = nsuri;
       }
+      /** Search the Store
+       *
+       * ALL CONVENIENCE LOOKUP FUNCTIONS RELY ON THIS!
+       * @param subj - A node to search for as subject, or if null, a wildcard
+       * @param pred - A node to search for as predicate, or if null, a wildcard
+       * @param obj - A node to search for as object, or if null, a wildcard
+       * @param why - A node to search for as graph, or if null, a wildcard
+       * @param justOne - flag - stop when found one rather than get all of them?
+       * @returns An array of nodes which match the wildcard position
+       */
     }, {
       key: "statementsMatching",
       value: function statementsMatching(subj, pred, obj, why, justOne) {
@@ -33258,6 +34359,10 @@ ${newlined}
         }
         return results;
       }
+      /**
+       * A list of all the URIs by which this thing is known
+       * @param term
+       */
     }, {
       key: "uris",
       value: function uris(term2) {
@@ -33299,6 +34404,7 @@ ${newlined}
     return encodeURI(str);
   }
   var Utf8 = {
+    // public method for url encoding
     encode: function encode3(string) {
       string = string.replace(/\r\n/g, "\n");
       var utftext = "";
@@ -33317,6 +34423,7 @@ ${newlined}
       }
       return utftext;
     },
+    // public method for url decoding
     decode: function decode3(utftext) {
       var string = "";
       var i = 0;
@@ -34675,6 +35782,10 @@ ${newlined}
   }
   var ExtendedTermFactory = _objectSpread2(_objectSpread2({}, canonical_data_factory_default), {}, {
     supports: (_supports2 = {}, _defineProperty(_supports2, Feature.collections, true), _defineProperty(_supports2, Feature.defaultGraphType, false), _defineProperty(_supports2, Feature.equalsMethod, true), _defineProperty(_supports2, Feature.identity, false), _defineProperty(_supports2, Feature.id, true), _defineProperty(_supports2, Feature.reversibleId, false), _defineProperty(_supports2, Feature.variableType, true), _supports2),
+    /**
+     * Creates a new collection
+     * @param elements - The initial element
+     */
     collection: function collection(elements) {
       return new Collection(elements);
     },
@@ -35754,102 +36865,122 @@ ${newlined}
     }
     _createClass(RDFParser2, [{
       key: "frameFactory",
-      value: function frameFactory(parser, parent2, element) {
-        return {
-          "NODE": 1,
-          "ARC": 2,
-          "parent": parent2,
-          "parser": parser,
-          "store": parser.store,
-          "element": element,
-          "lastChild": 0,
-          "base": null,
-          "lang": null,
-          "node": null,
-          "nodeType": null,
-          "listIndex": 1,
-          "rdfid": null,
-          "datatype": null,
-          "collection": false,
-          "terminateFrame": function terminateFrame() {
-            if (this.collection) {
-              this.node.close();
-            }
-          },
-          "addSymbol": function addSymbol(type, uri) {
-            uri = join(uri, this.base);
-            this.node = this.store.sym(uri);
-            this.nodeType = type;
-          },
-          "loadTriple": function loadTriple() {
-            if (this.parent.parent.collection) {
-              this.parent.parent.node.append(this.node);
-            } else {
-              this.store.add(this.parent.parent.node, this.parent.node, this.node, this.parser.why);
-            }
-            if (this.parent.rdfid != null) {
-              var triple3 = this.store.sym(join("#" + this.parent.rdfid, this.base));
-              this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "type"), this.store.sym(RDFParser2.ns.RDF + "Statement"), this.parser.why);
-              this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "subject"), this.parent.parent.node, this.parser.why);
-              this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "predicate"), this.parent.node, this.parser.why);
-              this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "object"), this.node, this.parser.why);
-            }
-          },
-          "isTripleToLoad": function isTripleToLoad() {
-            return this.parent != null && this.parent.parent != null && this.nodeType === this.NODE && this.parent.nodeType === this.ARC && this.parent.parent.nodeType === this.NODE;
-          },
-          "addNode": function addNode(uri) {
-            this.addSymbol(this.NODE, uri);
-            if (this.isTripleToLoad()) {
-              this.loadTriple();
-            }
-          },
-          "addCollection": function addCollection() {
-            this.nodeType = this.NODE;
-            this.node = this.store.collection();
-            this.collection = true;
-            if (this.isTripleToLoad()) {
-              this.loadTriple();
-            }
-          },
-          "addCollectionArc": function addCollectionArc() {
-            this.nodeType = this.ARC;
-          },
-          "addBNode": function addBNode(id3) {
-            if (id3 != null) {
-              if (this.parser.bnodes[id3] != null) {
-                this.node = this.parser.bnodes[id3];
+      value: (
+        /**
+         * Frame class for namespace and base URI lookups
+         * Base lookups will always resolve because the parser knows
+         * the default base.
+         *
+         * @private
+         */
+        function frameFactory(parser, parent2, element) {
+          return {
+            "NODE": 1,
+            "ARC": 2,
+            "parent": parent2,
+            "parser": parser,
+            "store": parser.store,
+            "element": element,
+            "lastChild": 0,
+            "base": null,
+            "lang": null,
+            "node": null,
+            "nodeType": null,
+            "listIndex": 1,
+            "rdfid": null,
+            "datatype": null,
+            "collection": false,
+            /** Terminate the frame and notify the store that we're done */
+            "terminateFrame": function terminateFrame() {
+              if (this.collection) {
+                this.node.close();
+              }
+            },
+            /** Add a symbol of a certain type to the this frame */
+            "addSymbol": function addSymbol(type, uri) {
+              uri = join(uri, this.base);
+              this.node = this.store.sym(uri);
+              this.nodeType = type;
+            },
+            /** Load any constructed triples into the store */
+            "loadTriple": function loadTriple() {
+              if (this.parent.parent.collection) {
+                this.parent.parent.node.append(this.node);
               } else {
-                this.node = this.parser.bnodes[id3] = this.store.bnode();
+                this.store.add(this.parent.parent.node, this.parent.node, this.node, this.parser.why);
+              }
+              if (this.parent.rdfid != null) {
+                var triple3 = this.store.sym(join("#" + this.parent.rdfid, this.base));
+                this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "type"), this.store.sym(RDFParser2.ns.RDF + "Statement"), this.parser.why);
+                this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "subject"), this.parent.parent.node, this.parser.why);
+                this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "predicate"), this.parent.node, this.parser.why);
+                this.store.add(triple3, this.store.sym(RDFParser2.ns.RDF + "object"), this.node, this.parser.why);
+              }
+            },
+            /** Check if it's OK to load a triple */
+            "isTripleToLoad": function isTripleToLoad() {
+              return this.parent != null && this.parent.parent != null && this.nodeType === this.NODE && this.parent.nodeType === this.ARC && this.parent.parent.nodeType === this.NODE;
+            },
+            /** Add a symbolic node to this frame */
+            "addNode": function addNode(uri) {
+              this.addSymbol(this.NODE, uri);
+              if (this.isTripleToLoad()) {
+                this.loadTriple();
+              }
+            },
+            /** Add a collection node to this frame */
+            "addCollection": function addCollection() {
+              this.nodeType = this.NODE;
+              this.node = this.store.collection();
+              this.collection = true;
+              if (this.isTripleToLoad()) {
+                this.loadTriple();
+              }
+            },
+            /** Add a collection arc to this frame */
+            "addCollectionArc": function addCollectionArc() {
+              this.nodeType = this.ARC;
+            },
+            /** Add a bnode to this frame */
+            "addBNode": function addBNode(id3) {
+              if (id3 != null) {
+                if (this.parser.bnodes[id3] != null) {
+                  this.node = this.parser.bnodes[id3];
+                } else {
+                  this.node = this.parser.bnodes[id3] = this.store.bnode();
+                }
+              } else {
+                this.node = this.store.bnode();
+              }
+              this.nodeType = this.NODE;
+              if (this.isTripleToLoad()) {
+                this.loadTriple();
+              }
+            },
+            /** Add an arc or property to this frame */
+            "addArc": function addArc(uri) {
+              if (uri === RDFParser2.ns.RDF + "li") {
+                uri = RDFParser2.ns.RDF + "_" + this.parent.listIndex;
+                this.parent.listIndex++;
+              }
+              this.addSymbol(this.ARC, uri);
+            },
+            /** Add a literal to this frame */
+            "addLiteral": function addLiteral(value) {
+              if (this.parent.datatype && this.parent.datatype !== RDFParser2.ns.RDF + "langString") {
+                this.node = this.store.literal(value, this.store.sym(this.parent.datatype));
+              } else {
+                this.node = this.store.literal(value, this.lang);
+              }
+              this.nodeType = this.NODE;
+              if (this.isTripleToLoad()) {
+                this.loadTriple();
               }
-            } else {
-              this.node = this.store.bnode();
-            }
-            this.nodeType = this.NODE;
-            if (this.isTripleToLoad()) {
-              this.loadTriple();
-            }
-          },
-          "addArc": function addArc(uri) {
-            if (uri === RDFParser2.ns.RDF + "li") {
-              uri = RDFParser2.ns.RDF + "_" + this.parent.listIndex;
-              this.parent.listIndex++;
-            }
-            this.addSymbol(this.ARC, uri);
-          },
-          "addLiteral": function addLiteral(value) {
-            if (this.parent.datatype && this.parent.datatype !== RDFParser2.ns.RDF + "langString") {
-              this.node = this.store.literal(value, this.store.sym(this.parent.datatype));
-            } else {
-              this.node = this.store.literal(value, this.lang);
-            }
-            this.nodeType = this.NODE;
-            if (this.isTripleToLoad()) {
-              this.loadTriple();
             }
-          }
-        };
-      }
+          };
+        }
+      )
+      // from the OpenLayers source .. needed to get around IE problems.
     }, {
       key: "getAttributeNodeNS",
       value: function getAttributeNodeNS(node, uri, name) {
@@ -35872,6 +37003,12 @@ ${newlined}
         }
         return attributeNode;
       }
+      /**
+       * Build our initial scope frame and parse the DOM into triples
+       * @param {HTMLDocument} document The DOM to parse
+       * @param {String} base The base URL to use
+       * @param {Object} why The context to which this resource belongs
+       */
     }, {
       key: "parse",
       value: function parse3(document3, base, why) {
@@ -36059,12 +37196,20 @@ ${newlined}
           }
         }
       }
+      /**
+       * Cleans out state from a previous parse run
+       * @private
+       */
     }, {
       key: "cleanParser",
       value: function cleanParser() {
         this.bnodes = {};
         this.why = null;
       }
+      /**
+       * Builds scope frame
+       * @private
+       */
     }, {
       key: "buildFrame",
       value: function buildFrame(parent2, element) {
@@ -36250,7 +37395,10 @@ ${newlined}
       }
     }
     function executeErrorCallback(e) {
-      if (contentType !== JSONLDContentType || contentType !== NQuadsContentType || contentType !== NQuadsAltContentType) {
+      if (// TODO: Always true, what is the right behavior
+      contentType !== JSONLDContentType || // @ts-ignore always true?
+      contentType !== NQuadsContentType || // @ts-ignore always true?
+      contentType !== NQuadsAltContentType) {
         if (callback) {
           callback(e, kb);
         } else {
@@ -36332,6 +37480,7 @@ ${newlined}
       link: Namespace("http://www.w3.org/2007/ont/link#", factory),
       http: Namespace("http://www.w3.org/2007/ont/http#", factory),
       httph: Namespace("http://www.w3.org/2007/ont/httph#", factory),
+      // headers
       rdf: Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#", factory),
       rdfs: Namespace("http://www.w3.org/2000/01/rdf-schema#", factory),
       dc: Namespace("http://purl.org/dc/elements/1.1/", factory),
@@ -36340,6 +37489,8 @@ ${newlined}
   };
   var ns2 = getNS();
   var Handler = /* @__PURE__ */ _createClass(
+    // TODO: Document, type
+    // TODO: Document, type
     function Handler2(response, dom) {
       _classCallCheck(this, Handler2);
       _defineProperty(this, "response", void 0);
@@ -36762,6 +37913,7 @@ ${newlined}
         "*/*": {
           "q": 0.1
         }
+        // Must allow access to random content
       };
       callbackify(this, ["request", "fail", "refresh", "retract", "done"]);
       Object.keys(options.handlers || defaultHandlers).map(function(key) {
@@ -36770,22 +37922,69 @@ ${newlined}
     }
     _createClass(Fetcher3, [{
       key: "load",
-      value: function load(uri) {
-        var _this2 = this;
-        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-        options = Object.assign({}, options);
-        if (uri instanceof Array) {
-          return Promise.all(uri.map(function(x) {
-            return _this2.load(x, Object.assign({}, options));
-          }));
+      value: (
+        /**
+         * Promise-based load function
+         *
+         * Loads a web resource or resources into the store.
+         *
+         * A resource may be given as NamedNode object, or as a plain URI.
+         * an array of resources will be given, in which they will be fetched in parallel.
+         * By default, the HTTP headers are recorded also, in the same store, in a separate graph.
+         * This allows code like editable() for example to test things about the resource.
+         *
+         * @param uri {Array<RDFlibNamedNode>|Array<string>|RDFlibNamedNode|string}
+         *
+         * @param [options={}] {Object}
+         *
+         * @param [options.fetch] {Function}
+         *
+         * @param [options.referringTerm] {RDFlibNamedNode} Referring term, the resource which
+         *   referred to this (for tracking bad links)
+         *
+         * @param [options.contentType] {string} Provided content type (for writes)
+         *
+         * @param [options.forceContentType] {string} Override the incoming header to
+         *   force the data to be treated as this content-type (for reads)
+         *
+         * @param [options.force] {boolean} Load the data even if loaded before.
+         *   Also sets the `Cache-Control:` header to `no-cache`
+         *
+         * @param [options.baseURI=docuri] {Node|string} Original uri to preserve
+         *   through proxying etc (`xhr.original`).
+         *
+         * @param [options.proxyUsed] {boolean} Whether this request is a retry via
+         *   a proxy (generally done from an error handler)
+         *
+         * @param [options.withCredentials] {boolean} flag for XHR/CORS etc
+         *
+         * @param [options.clearPreviousData] {boolean} Before we parse new data,
+         *   clear old, but only on status 200 responses
+         *
+         * @param [options.noMeta] {boolean} Prevents the addition of various metadata
+         *   triples (about the fetch request) to the store
+         *
+         * @param [options.noRDFa] {boolean}
+         *
+         * @returns {Promise<Result>}
+         */
+        function load(uri) {
+          var _this2 = this;
+          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+          options = Object.assign({}, options);
+          if (uri instanceof Array) {
+            return Promise.all(uri.map(function(x) {
+              return _this2.load(x, Object.assign({}, options));
+            }));
+          }
+          var uriIn = uri;
+          var docuri = termValue(uriIn);
+          docuri = docuri.split("#")[0];
+          options = this.initFetchOptions(docuri, options);
+          var initialisedOptions = this.initFetchOptions(docuri, options);
+          return this.pendingFetchPromise(docuri, initialisedOptions.baseURI, initialisedOptions);
         }
-        var uriIn = uri;
-        var docuri = termValue(uriIn);
-        docuri = docuri.split("#")[0];
-        options = this.initFetchOptions(docuri, options);
-        var initialisedOptions = this.initFetchOptions(docuri, options);
-        return this.pendingFetchPromise(docuri, initialisedOptions.baseURI, initialisedOptions);
-      }
+      )
     }, {
       key: "pendingFetchPromise",
       value: function pendingFetchPromise(uri, originalUri, options) {
@@ -36806,6 +38005,9 @@ ${newlined}
           return x;
         });
       }
+      /**
+       * @param _options - DEPRECATED
+       */
     }, {
       key: "cleanupFetchRequest",
       value: function cleanupFetchRequest(originalUri, _options, timeout2) {
@@ -36850,6 +38052,14 @@ ${newlined}
         options.actualProxyURI = actualProxyURI;
         return options;
       }
+      /**
+       * (The promise chain ends in either a `failFetch()` or a `doneFetch()`)
+       *
+       * @param docuri {string}
+       * @param options {Object}
+       *
+       * @returns {Promise<Object>} fetch() result or an { error, status } object
+       */
     }, {
       key: "fetchUri",
       value: function fetchUri(docuri, options) {
@@ -36864,6 +38074,7 @@ ${newlined}
         if (!options.force) {
           if (state === "fetched") {
             return Promise.resolve(
+              // @ts-ignore This is not a valid response object
               this.doneFetch(options, {
                 status: 200,
                 ok: true,
@@ -36875,10 +38086,12 @@ ${newlined}
             var _message = "Previously failed: " + this.requested[docuri];
             var dummyResponse = {
               url: docuri,
+              // This does not comply to Fetch spec, it can be a string value in rdflib
               status: this.requested[docuri],
               statusText: _message,
               responseText: _message,
               headers: new import_cross_fetch.Headers(),
+              // Headers() ???
               ok: false,
               body: null,
               bodyUsed: false,
@@ -36902,9 +38115,11 @@ ${newlined}
           var dummyResponse2 = {
             url: actualProxyURI,
             status: 999,
+            // @@ what number/string should fetch failures report?
             statusText: (error2.name || "network failure") + ": " + (error2.errno || error2.code || error2.type),
             responseText: error2.message,
             headers: new import_cross_fetch.Headers(),
+            // Headers() ???
             ok: false,
             body: null,
             bodyUsed: false,
@@ -36915,6 +38130,33 @@ ${newlined}
           return _this5.handleError(dummyResponse2, docuri, options);
         });
       }
+      /**
+       * Asks for a doc to be loaded if necessary then calls back
+       *
+       * Calling methods:
+       *   nowOrWhenFetched (uri, userCallback)
+       *   nowOrWhenFetched (uri, options, userCallback)
+       *   nowOrWhenFetched (uri, referringTerm, userCallback, options)  <-- old
+       *   nowOrWhenFetched (uri, referringTerm, userCallback) <-- old
+       *
+       *  Options include:
+       *   referringTerm    The document in which this link was found.
+       *                    this is valuable when finding the source of bad URIs
+       *   force            boolean.  Never mind whether you have tried before,
+       *                    load this from scratch.
+       *   forceContentType Override the incoming header to force the data to be
+       *                    treated as this content-type.
+       *
+       *  Callback function takes:
+       *
+       *    ok               True if the fetch worked, and got a 200 response.
+       *                     False if any error happened
+       *
+       *    errmessage       Text error message if not OK.
+       *
+       *    response         The fetch Response object (was: XHR) if there was was one
+       *                     includes response.status as the HTTP status if any.
+       */
     }, {
       key: "nowOrWhenFetched",
       value: function nowOrWhenFetched(uriIn, p2, userCallback) {
@@ -36957,6 +38199,11 @@ ${newlined}
           userCallback(false, message2, err.response);
         });
       }
+      /**
+       * Records a status message (as a literal node) by appending it to the
+       * request's metadata status collection.
+       *
+       */
     }, {
       key: "addStatus",
       value: function addStatus(req, statusMessage) {
@@ -36970,6 +38217,14 @@ ${newlined}
           log_default.warn("web.js: No list to add to: " + statusNode + "," + statusMessage);
         }
       }
+      /**
+       * Records errors in the system on failure:
+       *
+       *  - Adds an entry to the request status collection
+       *  - Adds an error triple with the fail message to the metadata
+       *  - Fires the 'fail' callback
+       *  - Rejects with an error result object, which has a response object if any
+       */
     }, {
       key: "failFetch",
       value: function failFetch(options, errorMessage, statusCode, response) {
@@ -36992,6 +38247,8 @@ ${newlined}
         err.response = response;
         return Promise.reject(err);
       }
+      // in the why part of the quad distinguish between HTML and HTTP header
+      // Reverse is set iif the link was rev= as opposed to rel=
     }, {
       key: "linkData",
       value: function linkData(originalUri, rel, uri, why, reverse) {
@@ -37051,6 +38308,11 @@ ${newlined}
         response.req = options.req;
         return response;
       }
+      /**
+       * Note two nodes are now smushed
+       * If only one was flagged as looked up, then the new node is looked up again,
+       * which will make sure all the URIs are dereferenced
+       */
     }, {
       key: "nowKnownAs",
       value: function nowKnownAs(was, now) {
@@ -37064,6 +38326,9 @@ ${newlined}
           }
         }
       }
+      /**
+       * Writes back to the web what we have in the store for this uri
+       */
     }, {
       key: "putBack",
       value: function putBack(uri) {
@@ -37098,6 +38363,7 @@ ${newlined}
         return this.webOperation("GET", here).then(function(result) {
           return _this7.webOperation(
             "PUT",
+            // change to binary from text
             there,
             {
               data: result.responseText,
@@ -37117,6 +38383,11 @@ ${newlined}
           return response;
         });
       }
+      /** Create an empty resource if it really does not exist
+       *  Be absolutely sure something does not exist before creating a new empty file
+       * as otherwise existing could  be deleted.
+       * @param doc - The resource
+      */
     }, {
       key: "createIfNotExists",
       value: function() {
@@ -37179,10 +38450,16 @@ ${newlined}
         }
         return createIfNotExists;
       }()
+      /**
+       * @param parentURI URI of parent container
+       * @param folderName - Optional folder name (slug)
+       * @param data - Optional folder metadata
+       */
     }, {
       key: "createContainer",
       value: function createContainer(parentURI, folderName, data) {
         var headers = {
+          // Force the right mime type for containers
           "content-type": TurtleContentType,
           "link": this.ns.ldp("BasicContainer") + '; rel="type"'
         };
@@ -37220,6 +38497,13 @@ ${newlined}
           delete fetcher3.nonexistent[uri];
         }
       }
+      /**
+       * A generic web operation, at the fetch() level.
+       * does not involve the quad store.
+       *
+       *  Returns promise of Response
+       *  If data is returned, copies it to response.responseText before returning
+       */
     }, {
       key: "webOperation",
       value: function webOperation(method, uriIn) {
@@ -37268,6 +38552,15 @@ ${newlined}
           });
         });
       }
+      /**
+       * Looks up something.
+       * Looks up all the URIs a things has.
+       *
+       * @param term - canonical term for the thing whose URI is
+       *   to be dereferenced
+       * @param rterm - the resource which referred to this
+       *   (for tracking bad links)
+       */
     }, {
       key: "lookUpThing",
       value: function lookUpThing(term2, rterm) {
@@ -37283,6 +38576,14 @@ ${newlined}
           referringTerm: rterm
         });
       }
+      /**
+       * Looks up response header.
+       *
+       * @returns {Array|undefined} a list of header values found in a stored HTTP
+       *   response, or [] if response was found but no header found,
+       *   or undefined if no response is available.
+       * Looks for { [] link:requestedURI ?uri; link:response [ httph:header-name  ?value ] }
+       */
     }, {
       key: "getHeader",
       value: function getHeader(doc, header) {
@@ -37352,6 +38653,11 @@ ${newlined}
           }
         }
       }
+      /* refresh  Reload data from a given document
+      **
+      ** @param term - An RDF Named Node for the eodcument in question
+      ** @param userCallback - A function userCallback(ok, message, response)
+      */
     }, {
       key: "refresh",
       value: function refresh(term2, userCallback) {
@@ -37361,6 +38667,11 @@ ${newlined}
           clearPreviousData: true
         }, userCallback);
       }
+      /* refreshIfExpired   Conditional refresh if Expired
+      **
+      ** @param term - An RDF Named Node for the eodcument in question
+      ** @param userCallback - A function userCallback(ok, message, response)
+      */
     }, {
       key: "refreshIfExpired",
       value: function refreshIfExpired(term2, userCallback) {
@@ -37425,6 +38736,10 @@ ${newlined}
         this.addStatus(options.req, "Abort: Will retry with credentials SUPPRESSED to see if that helps");
         return this.load(docuri, newOptions);
       }
+      /**
+       * Tests whether a request is being made to a cross-site URI (for purposes
+       * of retrying with a proxy)
+       */
     }, {
       key: "isCrossSite",
       value: function isCrossSite(uri) {
@@ -37435,6 +38750,10 @@ ${newlined}
         var here = "" + document.location;
         return (hostpart2(here) && hostpart2(uri) && hostpart2(here)) !== hostpart2(uri);
       }
+      /**
+       * Called when there's a network error in fetch(), or a response
+       * with status of 0.
+       */
     }, {
       key: "handleError",
       value: function handleError(response, docuri, options) {
@@ -37459,6 +38778,7 @@ ${newlined}
         }
         return this.failFetch(options, message2, response.status || 998, response);
       }
+      // deduce some things from the HTTP transaction
     }, {
       key: "addType",
       value: function addType(rdfType, req, kb, locURI) {
@@ -37491,6 +38811,9 @@ ${newlined}
           }
         }
       }
+      /**
+       * Handle fetch() response
+       */
     }, {
       key: "handleResponse",
       value: function handleResponse(response, docuri, options) {
@@ -37602,6 +38925,9 @@ ${newlined}
         }
         return contentType;
       }
+      /**
+       * Sends a new request to the specified uri. (Extracted from `onerrorFactory()`)
+       */
     }, {
       key: "redirectToProxy",
       value: function redirectToProxy(newURI, options) {
@@ -37661,6 +38987,9 @@ ${newlined}
         }
         return acceptstring;
       }
+      // var updatesVia = new $rdf.UpdatesVia(this) // Subscribe to headers
+      // @@@@@@@@ This is turned off because it causes a websocket to be set up for ANY fetch
+      // whether we want to track it ot not. including ontologies loaed though the XSSproxy
     }], [{
       key: "crossSiteProxy",
       value: function crossSiteProxy(uri) {
@@ -37712,17 +39041,26 @@ ${newlined}
             return y;
           }
         }
-        if (Fetcher3.crossSiteProxyTemplate && typeof document !== "undefined" && document.location && ("" + document.location).slice(0, 6) === "https:" && uri.slice(0, 5) === "http:") {
+        if (Fetcher3.crossSiteProxyTemplate && typeof document !== "undefined" && document.location && ("" + document.location).slice(0, 6) === "https:" && // origin is secure
+        uri.slice(0, 5) === "http:") {
           return Fetcher3.crossSiteProxyTemplate.replace("{uri}", encodeURIComponent(uri));
         }
         return uri;
       }
+      /**
+       * Tests whether the uri's protocol is supported by the Fetcher.
+       * @param uri
+       */
     }, {
       key: "unsupportedProtocol",
       value: function unsupportedProtocol(uri) {
         var pcol = protocol(uri);
         return pcol === "tel" || pcol === "mailto" || pcol === "urn";
       }
+      /** Decide on credentials using old XXHR api or new fetch()  one
+       * @param requestedURI
+       * @param options
+       */
     }, {
       key: "setCredentials",
       value: function setCredentials(requestedURI) {
@@ -37767,9 +39105,17 @@ ${newlined}
     return target;
   }
   var RDFlibDataFactory = _objectSpread3(_objectSpread3({}, extended_term_factory_default), {}, {
+    /**
+     * Creates a new fetcher
+     * @param store - The store to use
+     * @param options - The options
+     */
     fetcher: function fetcher(store, options) {
       return new Fetcher(store, options);
     },
+    /**
+     * Creates a new graph (store)
+     */
     graph: function graph() {
       var features = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : void 0;
       var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : void 0;
@@ -37777,9 +39123,22 @@ ${newlined}
         rdfFactory: extended_term_factory_default
       });
     },
+    /**
+     * Creates a new literal node
+     * @param val The lexical value
+     * @param lang The language
+     * @param dt The datatype
+     */
     lit: function lit(val, lang, dt) {
       return this.literal("" + val, lang || dt);
     },
+    /**
+     * Creates a new statement
+     * @param subject The subject
+     * @param predicate The predicate
+     * @param object The object
+     * @param graph The containing graph
+     */
     st: function st(subject, predicate, object, graph3) {
       return this.quad(subject, predicate, object, graph3);
     }
@@ -38036,68 +39395,111 @@ ${newlined}
   };
   return __toCommonJS(src_exports);
 })();
-/*!
- * Copyright (c) 2016-2021 Digital Bazaar, Inc. All rights reserved.
- */
-/*!
- * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
- */
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <http://feross.org>
- * @license  MIT
- */
-/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
- */
-/*! Mike Samuel (c) 2009 | code.google.com/p/json-sans-eval
- */
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
-/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
-/**
- * A JavaScript implementation of the JSON-LD API.
- *
- * @author Dave Longley
- *
- * @license BSD 3-Clause License
- * Copyright (c) 2011-2019 Digital Bazaar, Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- *
- * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * Neither the name of the Digital Bazaar, Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
- * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/**
- * Removes the @preserve keywords from expanded result of framing.
- *
- * @param input the framed, framed output.
- * @param options the framing options used.
- *
- * @return the resulting output.
- */
-// disallow aliasing @context and @preserve
-// remove @preserve
-// remove @preserve from results
+/*! Bundled license information:
+
+@inrupt/oidc-client/lib/oidc-client.min.js:
+  (*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
+   *)
+  (*! Mike Samuel (c) 2009 | code.google.com/p/json-sans-eval
+   *)
+  (*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <http://feross.org>
+   * @license  MIT
+   *)
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+rdf-canonize/lib/MessageDigest-browser.js:
+  (*!
+   * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+   *)
+
+rdf-canonize/lib/Permuter.js:
+  (*!
+   * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+   *)
+
+rdf-canonize/lib/NQuads.js:
+  (*!
+   * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+   *)
+
+rdf-canonize/lib/URDNA2015.js:
+  (*!
+   * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+   *)
+
+rdf-canonize/lib/URGNA2012.js:
+  (*!
+   * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+   *)
+
+rdf-canonize/lib/URDNA2015Sync.js:
+  (*!
+   * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+   *)
+
+rdf-canonize/lib/URGNA2012Sync.js:
+  (*!
+   * Copyright (c) 2016-2021 Digital Bazaar, Inc. All rights reserved.
+   *)
+
+jsonld/lib/context.js:
+  (* disallow aliasing @context and @preserve *)
+
+jsonld/lib/frame.js:
+  (* remove @preserve from results *)
+  (**
+   * Removes the @preserve keywords from expanded result of framing.
+   *
+   * @param input the framed, framed output.
+   * @param options the framing options used.
+   *
+   * @return the resulting output.
+   *)
+  (* remove @preserve *)
+
+jsonld/lib/jsonld.js:
+  (**
+   * A JavaScript implementation of the JSON-LD API.
+   *
+   * @author Dave Longley
+   *
+   * @license BSD 3-Clause License
+   * Copyright (c) 2011-2019 Digital Bazaar, Inc.
+   * All rights reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * Redistributions of source code must retain the above copyright notice,
+   * this list of conditions and the following disclaimer.
+   *
+   * Redistributions in binary form must reproduce the above copyright
+   * notice, this list of conditions and the following disclaimer in the
+   * documentation and/or other materials provided with the distribution.
+   *
+   * Neither the name of the Digital Bazaar, Inc. nor the names of its
+   * contributors may be used to endorse or promote products derived from
+   * this software without specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+   * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+   * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+queue-microtask/index.js:
+  (*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+@babel/runtime/helpers/regeneratorRuntime.js:
+  (*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE *)
+*/