solid-ui 2.4.28-df3d9431 → 2.4.28-e3ba3633

package/dist/vendors-node_modules_jsonld_lib_jsonld_js.solid-ui.js

@@ -485,7 +485,7 @@ module.exports = class RequestQueue {
  */
 
 
-const LRU = __webpack_require__(/*! lru-cache */ "./node_modules/jsonld/node_modules/lru-cache/index.js");
+const LRU = __webpack_require__(/*! lru-cache */ "./node_modules/lru-cache/index.js");
 
 const MAX_ACTIVE_CONTEXTS = 10;
 
@@ -6383,7 +6383,7 @@ const util = __webpack_require__(/*! ./util */ "./node_modules/jsonld/lib/util.j
 const ContextResolver = __webpack_require__(/*! ./ContextResolver */ "./node_modules/jsonld/lib/ContextResolver.js");
 const IdentifierIssuer = util.IdentifierIssuer;
 const JsonLdError = __webpack_require__(/*! ./JsonLdError */ "./node_modules/jsonld/lib/JsonLdError.js");
-const LRU = __webpack_require__(/*! lru-cache */ "./node_modules/jsonld/node_modules/lru-cache/index.js");
+const LRU = __webpack_require__(/*! lru-cache */ "./node_modules/lru-cache/index.js");
 const NQuads = __webpack_require__(/*! ./NQuads */ "./node_modules/jsonld/lib/NQuads.js");
 
 const {expand: _expand} = __webpack_require__(/*! ./expand */ "./node_modules/jsonld/lib/expand.js");
@@ -9014,17 +9014,17 @@ function _labelBlankNodes(issuer, element) {
 
 /***/ }),
 
-/***/ "./node_modules/jsonld/node_modules/lru-cache/index.js":
-/*!*************************************************************!*\
-  !*** ./node_modules/jsonld/node_modules/lru-cache/index.js ***!
-  \*************************************************************/
+/***/ "./node_modules/lru-cache/index.js":
+/*!*****************************************!*\
+  !*** ./node_modules/lru-cache/index.js ***!
+  \*****************************************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
 
 // A linked list to keep track of recently-used-ness
-const Yallist = __webpack_require__(/*! yallist */ "./node_modules/jsonld/node_modules/yallist/yallist.js")
+const Yallist = __webpack_require__(/*! yallist */ "./node_modules/yallist/yallist.js")
 
 const MAX = Symbol('max')
 const LENGTH = Symbol('length')
@@ -9359,1141 +9359,1223 @@ module.exports = LRUCache
 
 /***/ }),
 
-/***/ "./node_modules/jsonld/node_modules/yallist/iterator.js":
-/*!**************************************************************!*\
-  !*** ./node_modules/jsonld/node_modules/yallist/iterator.js ***!
-  \**************************************************************/
-/***/ ((module) => {
-
-"use strict";
+/***/ "./node_modules/rdf-canonize/index.js":
+/*!********************************************!*\
+  !*** ./node_modules/rdf-canonize/index.js ***!
+  \********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-module.exports = function (Yallist) {
-  Yallist.prototype[Symbol.iterator] = function* () {
-    for (let walker = this.head; walker; walker = walker.next) {
-      yield walker.value
-    }
-  }
-}
+/**
+ * An implementation of the RDF Dataset Normalization specification.
+ *
+ * @author Dave Longley
+ *
+ * Copyright 2010-2021 Digital Bazaar, Inc.
+ */
+module.exports = __webpack_require__(/*! ./lib */ "./node_modules/rdf-canonize/lib/index.js");
 
 
 /***/ }),
 
-/***/ "./node_modules/jsonld/node_modules/yallist/yallist.js":
-/*!*************************************************************!*\
-  !*** ./node_modules/jsonld/node_modules/yallist/yallist.js ***!
-  \*************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+/***/ "./node_modules/rdf-canonize/lib/IdentifierIssuer.js":
+/*!***********************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/IdentifierIssuer.js ***!
+  \***********************************************************/
+/***/ ((module) => {
 
 "use strict";
+/*
+ * Copyright (c) 2016-2021 Digital Bazaar, Inc. All rights reserved.
+ */
 
-module.exports = Yallist
-
-Yallist.Node = Node
-Yallist.create = Yallist
 
-function Yallist (list) {
-  var self = this
-  if (!(self instanceof Yallist)) {
-    self = new Yallist()
+module.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 = new Map(), counter = 0) {
+    this.prefix = prefix;
+    this._existing = existing;
+    this.counter = counter;
   }
 
-  self.tail = null
-  self.head = null
-  self.length = 0
-
-  if (list && typeof list.forEach === 'function') {
-    list.forEach(function (item) {
-      self.push(item)
-    })
-  } else if (arguments.length > 0) {
-    for (var i = 0, l = arguments.length; i < l; i++) {
-      self.push(arguments[i])
-    }
+  /**
+   * Copies this IdentifierIssuer.
+   *
+   * @return a copy of this IdentifierIssuer.
+   */
+  clone() {
+    const {prefix, _existing, counter} = this;
+    return new IdentifierIssuer(prefix, new Map(_existing), counter);
   }
 
-  return self
-}
+  /**
+   * 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) {
+    // return existing old identifier
+    const existing = old && this._existing.get(old);
+    if(existing) {
+      return existing;
+    }
 
-Yallist.prototype.removeNode = function (node) {
-  if (node.list !== this) {
-    throw new Error('removing node which does not belong to this list')
-  }
+    // get next identifier
+    const identifier = this.prefix + this.counter;
+    this.counter++;
 
-  var next = node.next
-  var prev = node.prev
+    // save mapping
+    if(old) {
+      this._existing.set(old, identifier);
+    }
 
-  if (next) {
-    next.prev = prev
+    return identifier;
   }
 
-  if (prev) {
-    prev.next = next
+  /**
+   * 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);
   }
 
-  if (node === this.head) {
-    this.head = next
-  }
-  if (node === this.tail) {
-    this.tail = prev
+  /**
+   * 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()];
   }
+};
 
-  node.list.length--
-  node.next = null
-  node.prev = null
-  node.list = null
 
-  return next
-}
+/***/ }),
 
-Yallist.prototype.unshiftNode = function (node) {
-  if (node === this.head) {
-    return
-  }
+/***/ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js":
+/*!****************************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/MessageDigest-browser.js ***!
+  \****************************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-  if (node.list) {
-    node.list.removeNode(node)
-  }
+"use strict";
+/*!
+ * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+ */
 
-  var head = this.head
-  node.list = this
-  node.next = head
-  if (head) {
-    head.prev = node
-  }
 
-  this.head = node
-  if (!this.tail) {
-    this.tail = node
-  }
-  this.length++
-}
+__webpack_require__(/*! setimmediate */ "./node_modules/setimmediate/setImmediate.js");
 
-Yallist.prototype.pushNode = function (node) {
-  if (node === this.tail) {
-    return
-  }
+const crypto = self.crypto || self.msCrypto;
 
-  if (node.list) {
-    node.list.removeNode(node)
+module.exports = class MessageDigest {
+  /**
+   * Creates a new MessageDigest.
+   *
+   * @param algorithm the algorithm to use.
+   */
+  constructor(algorithm) {
+    // check if crypto.subtle is available
+    // check is here rather than top-level to only fail if class is used
+    if(!(crypto && crypto.subtle)) {
+      throw new Error('crypto.subtle not found.');
+    }
+    if(algorithm === 'sha256') {
+      this.algorithm = {name: 'SHA-256'};
+    } else if(algorithm === 'sha1') {
+      this.algorithm = {name: 'SHA-1'};
+    } else {
+      throw new Error(`Unsupported algorithm "${algorithm}".`);
+    }
+    this._content = '';
   }
 
-  var tail = this.tail
-  node.list = this
-  node.prev = tail
-  if (tail) {
-    tail.next = node
+  update(msg) {
+    this._content += msg;
   }
 
-  this.tail = node
-  if (!this.head) {
-    this.head = node
+  async digest() {
+    const data = new TextEncoder().encode(this._content);
+    const buffer = new Uint8Array(
+      await crypto.subtle.digest(this.algorithm, data));
+    // return digest in hex
+    let hex = '';
+    for(let i = 0; i < buffer.length; ++i) {
+      hex += buffer[i].toString(16).padStart(2, '0');
+    }
+    return hex;
   }
-  this.length++
-}
+};
 
-Yallist.prototype.push = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    push(this, arguments[i])
-  }
-  return this.length
-}
 
-Yallist.prototype.unshift = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    unshift(this, arguments[i])
-  }
-  return this.length
-}
+/***/ }),
 
-Yallist.prototype.pop = function () {
-  if (!this.tail) {
-    return undefined
-  }
+/***/ "./node_modules/rdf-canonize/lib/NQuads.js":
+/*!*************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/NQuads.js ***!
+  \*************************************************/
+/***/ ((module) => {
 
-  var res = this.tail.value
-  this.tail = this.tail.prev
-  if (this.tail) {
-    this.tail.next = null
-  } else {
-    this.head = null
-  }
-  this.length--
-  return res
-}
+"use strict";
+/*!
+ * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+ */
 
-Yallist.prototype.shift = function () {
-  if (!this.head) {
-    return undefined
-  }
 
-  var res = this.head.value
-  this.head = this.head.next
-  if (this.head) {
-    this.head.prev = null
-  } else {
-    this.tail = null
-  }
-  this.length--
-  return res
-}
-
-Yallist.prototype.forEach = function (fn, thisp) {
-  thisp = thisp || this
-  for (var walker = this.head, i = 0; walker !== null; i++) {
-    fn.call(thisp, walker.value, i, this)
-    walker = walker.next
-  }
-}
+// eslint-disable-next-line no-unused-vars
+const TERMS = ['subject', 'predicate', 'object', 'graph'];
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const RDF_LANGSTRING = RDF + 'langString';
+const XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
 
-Yallist.prototype.forEachReverse = function (fn, thisp) {
-  thisp = thisp || this
-  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
-    fn.call(thisp, walker.value, i, this)
-    walker = walker.prev
-  }
-}
+const TYPE_NAMED_NODE = 'NamedNode';
+const TYPE_BLANK_NODE = 'BlankNode';
+const TYPE_LITERAL = 'Literal';
+const TYPE_DEFAULT_GRAPH = 'DefaultGraph';
 
-Yallist.prototype.get = function (n) {
-  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.next
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-}
+// build regexes
+const REGEX = {};
+(() => {
+  const iri = '(?:<([^:]+:[^>]*)>)';
+  // https://www.w3.org/TR/turtle/#grammar-production-BLANK_NODE_LABEL
+  const PN_CHARS_BASE =
+    'A-Z' + 'a-z' +
+    '\u00C0-\u00D6' +
+    '\u00D8-\u00F6' +
+    '\u00F8-\u02FF' +
+    '\u0370-\u037D' +
+    '\u037F-\u1FFF' +
+    '\u200C-\u200D' +
+    '\u2070-\u218F' +
+    '\u2C00-\u2FEF' +
+    '\u3001-\uD7FF' +
+    '\uF900-\uFDCF' +
+    '\uFDF0-\uFFFD';
+    // TODO:
+    //'\u10000-\uEFFFF';
+  const PN_CHARS_U =
+    PN_CHARS_BASE +
+    '_';
+  const PN_CHARS =
+    PN_CHARS_U +
+    '0-9' +
+    '-' +
+    '\u00B7' +
+    '\u0300-\u036F' +
+    '\u203F-\u2040';
+  const BLANK_NODE_LABEL =
+    '(_:' +
+      '(?:[' + PN_CHARS_U + '0-9])' +
+      '(?:(?:[' + PN_CHARS + '.])*(?:[' + PN_CHARS + ']))?' +
+    ')';
+  const bnode = BLANK_NODE_LABEL;
+  const plain = '"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"';
+  const datatype = '(?:\\^\\^' + iri + ')';
+  const language = '(?:@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*))';
+  const literal = '(?:' + plain + '(?:' + datatype + '|' + language + ')?)';
+  const ws = '[ \\t]+';
+  const wso = '[ \\t]*';
 
-Yallist.prototype.getReverse = function (n) {
-  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.prev
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-}
+  // define quad part regexes
+  const subject = '(?:' + iri + '|' + bnode + ')' + ws;
+  const property = iri + ws;
+  const object = '(?:' + iri + '|' + bnode + '|' + literal + ')' + wso;
+  const graphName = '(?:\\.|(?:(?:' + iri + '|' + bnode + ')' + wso + '\\.))';
 
-Yallist.prototype.map = function (fn, thisp) {
-  thisp = thisp || this
-  var res = new Yallist()
-  for (var walker = this.head; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this))
-    walker = walker.next
-  }
-  return res
-}
+  // end of line and empty regexes
+  REGEX.eoln = /(?:\r\n)|(?:\n)|(?:\r)/g;
+  REGEX.empty = new RegExp('^' + wso + '$');
 
-Yallist.prototype.mapReverse = function (fn, thisp) {
-  thisp = thisp || this
-  var res = new Yallist()
-  for (var walker = this.tail; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this))
-    walker = walker.prev
-  }
-  return res
-}
+  // full quad regex
+  REGEX.quad = new RegExp(
+    '^' + wso + subject + property + object + graphName + wso + '$');
+})();
 
-Yallist.prototype.reduce = function (fn, initial) {
-  var acc
-  var walker = this.head
-  if (arguments.length > 1) {
-    acc = initial
-  } else if (this.head) {
-    walker = this.head.next
-    acc = this.head.value
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
+module.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) {
+    // build RDF dataset
+    const dataset = [];
 
-  for (var i = 0; walker !== null; i++) {
-    acc = fn(acc, walker.value, i)
-    walker = walker.next
-  }
+    const graphs = {};
 
-  return acc
-}
+    // split N-Quad input into lines
+    const lines = input.split(REGEX.eoln);
+    let lineNumber = 0;
+    for(const line of lines) {
+      lineNumber++;
 
-Yallist.prototype.reduceReverse = function (fn, initial) {
-  var acc
-  var walker = this.tail
-  if (arguments.length > 1) {
-    acc = initial
-  } else if (this.tail) {
-    walker = this.tail.prev
-    acc = this.tail.value
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
+      // skip empty lines
+      if(REGEX.empty.test(line)) {
+        continue;
+      }
 
-  for (var i = this.length - 1; walker !== null; i--) {
-    acc = fn(acc, walker.value, i)
-    walker = walker.prev
-  }
+      // parse quad
+      const match = line.match(REGEX.quad);
+      if(match === null) {
+        throw new Error('N-Quads parse error on line ' + lineNumber + '.');
+      }
 
-  return acc
-}
+      // create RDF quad
+      const quad = {subject: null, predicate: null, object: null, graph: null};
 
-Yallist.prototype.toArray = function () {
-  var arr = new Array(this.length)
-  for (var i = 0, walker = this.head; walker !== null; i++) {
-    arr[i] = walker.value
-    walker = walker.next
-  }
-  return arr
-}
+      // get subject
+      if(match[1] !== undefined) {
+        quad.subject = {termType: TYPE_NAMED_NODE, value: match[1]};
+      } else {
+        quad.subject = {termType: TYPE_BLANK_NODE, value: match[2]};
+      }
 
-Yallist.prototype.toArrayReverse = function () {
-  var arr = new Array(this.length)
-  for (var i = 0, walker = this.tail; walker !== null; i++) {
-    arr[i] = walker.value
-    walker = walker.prev
-  }
-  return arr
-}
+      // get predicate
+      quad.predicate = {termType: TYPE_NAMED_NODE, value: match[3]};
 
-Yallist.prototype.slice = function (from, to) {
-  to = to || this.length
-  if (to < 0) {
-    to += this.length
-  }
-  from = from || 0
-  if (from < 0) {
-    from += this.length
-  }
-  var ret = new Yallist()
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0
-  }
-  if (to > this.length) {
-    to = this.length
-  }
-  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
-    walker = walker.next
-  }
-  for (; walker !== null && i < to; i++, walker = walker.next) {
-    ret.push(walker.value)
-  }
-  return ret
-}
+      // get object
+      if(match[4] !== undefined) {
+        quad.object = {termType: TYPE_NAMED_NODE, value: match[4]};
+      } else if(match[5] !== undefined) {
+        quad.object = {termType: TYPE_BLANK_NODE, value: match[5]};
+      } else {
+        quad.object = {
+          termType: TYPE_LITERAL,
+          value: undefined,
+          datatype: {
+            termType: TYPE_NAMED_NODE
+          }
+        };
+        if(match[7] !== undefined) {
+          quad.object.datatype.value = match[7];
+        } else if(match[8] !== undefined) {
+          quad.object.datatype.value = RDF_LANGSTRING;
+          quad.object.language = match[8];
+        } else {
+          quad.object.datatype.value = XSD_STRING;
+        }
+        quad.object.value = _unescape(match[6]);
+      }
 
-Yallist.prototype.sliceReverse = function (from, to) {
-  to = to || this.length
-  if (to < 0) {
-    to += this.length
-  }
-  from = from || 0
-  if (from < 0) {
-    from += this.length
-  }
-  var ret = new Yallist()
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0
-  }
-  if (to > this.length) {
-    to = this.length
-  }
-  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
-    walker = walker.prev
-  }
-  for (; walker !== null && i > from; i--, walker = walker.prev) {
-    ret.push(walker.value)
-  }
-  return ret
-}
+      // get graph
+      if(match[9] !== undefined) {
+        quad.graph = {
+          termType: TYPE_NAMED_NODE,
+          value: match[9]
+        };
+      } else if(match[10] !== undefined) {
+        quad.graph = {
+          termType: TYPE_BLANK_NODE,
+          value: match[10]
+        };
+      } else {
+        quad.graph = {
+          termType: TYPE_DEFAULT_GRAPH,
+          value: ''
+        };
+      }
 
-Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
-  if (start > this.length) {
-    start = this.length - 1
-  }
-  if (start < 0) {
-    start = this.length + start;
-  }
+      // only add quad if it is unique in its graph
+      if(!(quad.graph.value in graphs)) {
+        graphs[quad.graph.value] = [quad];
+        dataset.push(quad);
+      } else {
+        let unique = true;
+        const quads = graphs[quad.graph.value];
+        for(const q of quads) {
+          if(_compareTriples(q, quad)) {
+            unique = false;
+            break;
+          }
+        }
+        if(unique) {
+          quads.push(quad);
+          dataset.push(quad);
+        }
+      }
+    }
 
-  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
-    walker = walker.next
+    return dataset;
   }
 
-  var ret = []
-  for (var i = 0; walker && i < deleteCount; i++) {
-    ret.push(walker.value)
-    walker = this.removeNode(walker)
-  }
-  if (walker === null) {
-    walker = this.tail
+  /**
+   * 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);
+    }
+    const quads = [];
+    for(const quad of dataset) {
+      quads.push(NQuads.serializeQuad(quad));
+    }
+    return quads.sort().join('');
   }
 
-  if (walker !== this.head && walker !== this.tail) {
-    walker = walker.prev
-  }
+  /**
+   * 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 = '';
 
-  for (var i = 0; i < nodes.length; i++) {
-    walker = insert(this, walker, nodes[i])
-  }
-  return ret;
-}
+    // subject can only be NamedNode or BlankNode
+    if(s.termType === TYPE_NAMED_NODE) {
+      nquad += `<${s.value}>`;
+    } else {
+      nquad += `${s.value}`;
+    }
 
-Yallist.prototype.reverse = function () {
-  var head = this.head
-  var tail = this.tail
-  for (var walker = head; walker !== null; walker = walker.prev) {
-    var p = walker.prev
-    walker.prev = walker.next
-    walker.next = p
-  }
-  this.head = tail
-  this.tail = head
-  return this
-}
+    // predicate can only be NamedNode
+    nquad += ` <${p.value}> `;
 
-function insert (self, node, value) {
-  var inserted = node === self.head ?
-    new Node(value, null, node, self) :
-    new Node(value, node, node.next, self)
+    // object is NamedNode, BlankNode, or Literal
+    if(o.termType === TYPE_NAMED_NODE) {
+      nquad += `<${o.value}>`;
+    } else if(o.termType === TYPE_BLANK_NODE) {
+      nquad += o.value;
+    } else {
+      nquad += `"${_escape(o.value)}"`;
+      if(o.datatype.value === RDF_LANGSTRING) {
+        if(o.language) {
+          nquad += `@${o.language}`;
+        }
+      } else if(o.datatype.value !== XSD_STRING) {
+        nquad += `^^<${o.datatype.value}>`;
+      }
+    }
 
-  if (inserted.next === null) {
-    self.tail = inserted
+    // graph can only be NamedNode or BlankNode (or DefaultGraph, but that
+    // does not add to `nquad`)
+    if(g.termType === TYPE_NAMED_NODE) {
+      nquad += ` <${g.value}>`;
+    } else if(g.termType === TYPE_BLANK_NODE) {
+      nquad += ` ${g.value}`;
+    }
+
+    nquad += ' .\n';
+    return nquad;
   }
-  if (inserted.prev === null) {
-    self.head = inserted
+
+  /**
+   * 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(quad) {
+    return NQuads.serializeQuadComponents(
+      quad.subject, quad.predicate, quad.object, quad.graph);
   }
 
-  self.length++
+  /**
+   * 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 = [];
 
-  return inserted
-}
+    const termTypeMap = {
+      'blank node': TYPE_BLANK_NODE,
+      IRI: TYPE_NAMED_NODE,
+      literal: TYPE_LITERAL
+    };
 
-function push (self, item) {
-  self.tail = new Node(item, self.tail, null, self)
-  if (!self.head) {
-    self.head = self.tail
-  }
-  self.length++
-}
+    for(const graphName in dataset) {
+      const triples = dataset[graphName];
+      triples.forEach(triple => {
+        const quad = {};
+        for(const componentName in triple) {
+          const oldComponent = triple[componentName];
+          const newComponent = {
+            termType: termTypeMap[oldComponent.type],
+            value: oldComponent.value
+          };
+          if(newComponent.termType === TYPE_LITERAL) {
+            newComponent.datatype = {
+              termType: TYPE_NAMED_NODE
+            };
+            if('datatype' in oldComponent) {
+              newComponent.datatype.value = oldComponent.datatype;
+            }
+            if('language' in oldComponent) {
+              if(!('datatype' in oldComponent)) {
+                newComponent.datatype.value = RDF_LANGSTRING;
+              }
+              newComponent.language = oldComponent.language;
+            } else if(!('datatype' in oldComponent)) {
+              newComponent.datatype.value = XSD_STRING;
+            }
+          }
+          quad[componentName] = newComponent;
+        }
+        if(graphName === '@default') {
+          quad.graph = {
+            termType: TYPE_DEFAULT_GRAPH,
+            value: ''
+          };
+        } else {
+          quad.graph = {
+            termType: graphName.startsWith('_:') ?
+              TYPE_BLANK_NODE : TYPE_NAMED_NODE,
+            value: graphName
+          };
+        }
+        quads.push(quad);
+      });
+    }
 
-function unshift (self, item) {
-  self.head = new Node(item, null, self.head, self)
-  if (!self.tail) {
-    self.tail = self.head
+    return quads;
   }
-  self.length++
-}
+};
 
-function Node (value, prev, next, list) {
-  if (!(this instanceof Node)) {
-    return new Node(value, prev, next, list)
+/**
+ * Compares two RDF triples for equality.
+ *
+ * @param t1 the first triple.
+ * @param t2 the second triple.
+ *
+ * @return true if the triples are the same, false if not.
+ */
+function _compareTriples(t1, t2) {
+  // compare subject and object types first as it is the quickest check
+  if(!(t1.subject.termType === t2.subject.termType &&
+    t1.object.termType === t2.object.termType)) {
+    return false;
   }
-
-  this.list = list
-  this.value = value
-
-  if (prev) {
-    prev.next = this
-    this.prev = prev
-  } else {
-    this.prev = null
+  // compare values
+  if(!(t1.subject.value === t2.subject.value &&
+    t1.predicate.value === t2.predicate.value &&
+    t1.object.value === t2.object.value)) {
+    return false;
   }
-
-  if (next) {
-    next.prev = this
-    this.next = next
-  } else {
-    this.next = null
+  if(t1.object.termType !== TYPE_LITERAL) {
+    // no `datatype` or `language` to check
+    return true;
   }
+  return (
+    (t1.object.datatype.termType === t2.object.datatype.termType) &&
+    (t1.object.language === t2.object.language) &&
+    (t1.object.datatype.value === t2.object.datatype.value)
+  );
 }
 
-try {
-  // add if support for Symbol.iterator is present
-  __webpack_require__(/*! ./iterator.js */ "./node_modules/jsonld/node_modules/yallist/iterator.js")(Yallist)
-} catch (er) {}
-
-
-/***/ }),
-
-/***/ "./node_modules/rdf-canonize/index.js":
-/*!********************************************!*\
-  !*** ./node_modules/rdf-canonize/index.js ***!
-  \********************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+const _escapeRegex = /["\\\n\r]/g;
+/**
+ * Escape string to N-Quads literal
+ */
+function _escape(s) {
+  return s.replace(_escapeRegex, function(match) {
+    switch(match) {
+      case '"': return '\\"';
+      case '\\': return '\\\\';
+      case '\n': return '\\n';
+      case '\r': return '\\r';
+    }
+  });
+}
 
+const _unescapeRegex =
+  /(?:\\([tbnrf"'\\]))|(?:\\u([0-9A-Fa-f]{4}))|(?:\\U([0-9A-Fa-f]{8}))/g;
 /**
- * An implementation of the RDF Dataset Normalization specification.
- *
- * @author Dave Longley
- *
- * Copyright 2010-2021 Digital Bazaar, Inc.
+ * Unescape N-Quads literal to string
  */
-module.exports = __webpack_require__(/*! ./lib */ "./node_modules/rdf-canonize/lib/index.js");
+function _unescape(s) {
+  return s.replace(_unescapeRegex, function(match, code, u, U) {
+    if(code) {
+      switch(code) {
+        case 't': return '\t';
+        case 'b': return '\b';
+        case 'n': return '\n';
+        case 'r': return '\r';
+        case 'f': return '\f';
+        case '"': return '"';
+        case '\'': return '\'';
+        case '\\': return '\\';
+      }
+    }
+    if(u) {
+      return String.fromCharCode(parseInt(u, 16));
+    }
+    if(U) {
+      // FIXME: support larger values
+      throw new Error('Unsupported U escape');
+    }
+  });
+}
 
 
 /***/ }),
 
-/***/ "./node_modules/rdf-canonize/lib/IdentifierIssuer.js":
-/*!***********************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/IdentifierIssuer.js ***!
-  \***********************************************************/
+/***/ "./node_modules/rdf-canonize/lib/Permuter.js":
+/*!***************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/Permuter.js ***!
+  \***************************************************/
 /***/ ((module) => {
 
 "use strict";
-/*
- * Copyright (c) 2016-2021 Digital Bazaar, Inc. All rights reserved.
+/*!
+ * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
  */
 
 
-module.exports = class IdentifierIssuer {
+module.exports = class Permuter {
   /**
-   * Creates a new IdentifierIssuer. A IdentifierIssuer issues unique
-   * identifiers, keeping track of any previously issued identifiers.
+   * A Permuter iterates over all possible permutations of the given array
+   * of elements.
    *
-   * @param prefix the prefix to use ('<prefix><counter>').
-   * @param existing an existing Map to use.
-   * @param counter the counter to use.
+   * @param list the array of elements to iterate over.
    */
-  constructor(prefix, existing = new Map(), counter = 0) {
-    this.prefix = prefix;
-    this._existing = existing;
-    this.counter = counter;
+  constructor(list) {
+    // original array
+    this.current = list.sort();
+    // indicates whether there are more permutations
+    this.done = false;
+    // directional info for permutation algorithm
+    this.dir = new Map();
+    for(let i = 0; i < list.length; ++i) {
+      this.dir.set(list[i], true);
+    }
   }
 
   /**
-   * Copies this IdentifierIssuer.
+   * Returns true if there is another permutation.
    *
-   * @return a copy of this IdentifierIssuer.
+   * @return true if there is another permutation, false if not.
    */
-  clone() {
-    const {prefix, _existing, counter} = this;
-    return new IdentifierIssuer(prefix, new Map(_existing), counter);
+  hasNext() {
+    return !this.done;
   }
 
   /**
-   * 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.
+   * Gets the next permutation. Call hasNext() to ensure there is another one
+   * first.
    *
-   * @return the new identifier.
+   * @return the next permutation.
    */
-  getId(old) {
-    // return existing old identifier
-    const existing = old && this._existing.get(old);
-    if(existing) {
-      return existing;
+  next() {
+    // copy current permutation to return it
+    const {current, dir} = this;
+    const rval = current.slice();
+
+    /* Calculate the next permutation using the Steinhaus-Johnson-Trotter
+     permutation algorithm. */
+
+    // get largest mobile element k
+    // (mobile: element is greater than the one it is looking at)
+    let k = null;
+    let pos = 0;
+    const length = current.length;
+    for(let i = 0; i < length; ++i) {
+      const element = current[i];
+      const left = dir.get(element);
+      if((k === null || element > k) &&
+        ((left && i > 0 && element > current[i - 1]) ||
+        (!left && i < (length - 1) && element > current[i + 1]))) {
+        k = element;
+        pos = i;
+      }
     }
 
-    // get next identifier
-    const identifier = this.prefix + this.counter;
-    this.counter++;
+    // no more permutations
+    if(k === null) {
+      this.done = true;
+    } else {
+      // swap k and the element it is looking at
+      const swap = dir.get(k) ? pos - 1 : pos + 1;
+      current[pos] = current[swap];
+      current[swap] = k;
 
-    // save mapping
-    if(old) {
-      this._existing.set(old, identifier);
+      // reverse the direction of all elements larger than k
+      for(const element of current) {
+        if(element > k) {
+          dir.set(element, !dir.get(element));
+        }
+      }
     }
 
-    return identifier;
+    return rval;
   }
+};
 
-  /**
-   * 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()];
+/***/ }),
+
+/***/ "./node_modules/rdf-canonize/lib/URDNA2015.js":
+/*!****************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/URDNA2015.js ***!
+  \****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/*!
+ * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+
+
+const IdentifierIssuer = __webpack_require__(/*! ./IdentifierIssuer */ "./node_modules/rdf-canonize/lib/IdentifierIssuer.js");
+const MessageDigest = __webpack_require__(/*! ./MessageDigest */ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js");
+const Permuter = __webpack_require__(/*! ./Permuter */ "./node_modules/rdf-canonize/lib/Permuter.js");
+const NQuads = __webpack_require__(/*! ./NQuads */ "./node_modules/rdf-canonize/lib/NQuads.js");
+
+module.exports = class URDNA2015 {
+  constructor({
+    createMessageDigest = () => new MessageDigest('sha256'),
+    maxDeepIterations = Infinity
+  } = {}) {
+    this.name = 'URDNA2015';
+    this.blankNodeInfo = new Map();
+    this.canonicalIssuer = new IdentifierIssuer('_:c14n');
+    this.createMessageDigest = createMessageDigest;
+    this.maxDeepIterations = maxDeepIterations;
+    this.quads = null;
+    this.deepIterations = null;
   }
-};
 
+  // 4.4) Normalization Algorithm
+  async main(dataset) {
+    this.deepIterations = new Map();
+    this.quads = dataset;
+
+    // 1) Create the normalization state.
+    // 2) For every quad in input dataset:
+    for(const quad of dataset) {
+      // 2.1) For each blank node that occurs in the quad, add a reference
+      // to the quad using the blank node identifier in the blank node to
+      // quads map, creating a new entry if necessary.
+      this._addBlankNodeQuadInfo({quad, component: quad.subject});
+      this._addBlankNodeQuadInfo({quad, component: quad.object});
+      this._addBlankNodeQuadInfo({quad, component: quad.graph});
+    }
+
+    // 3) Create a list of non-normalized blank node identifiers
+    // non-normalized identifiers and populate it using the keys from the
+    // blank node to quads map.
+    // Note: We use a map here and it was generated during step 2.
+
+    // 4) `simple` flag is skipped -- loop is optimized away. This optimization
+    // is permitted because there was a typo in the hash first degree quads
+    // algorithm in the URDNA2015 spec that was implemented widely making it
+    // such that it could not be fixed; the result was that the loop only
+    // needs to be run once and the first degree quad hashes will never change.
+    // 5.1-5.2 are skipped; first degree quad hashes are generated just once
+    // for all non-normalized blank nodes.
+
+    // 5.3) For each blank node identifier identifier in non-normalized
+    // identifiers:
+    const hashToBlankNodes = new Map();
+    const nonNormalized = [...this.blankNodeInfo.keys()];
+    let i = 0;
+    for(const id of nonNormalized) {
+      // Note: batch hashing first degree quads 100 at a time
+      if(++i % 100 === 0) {
+        await this._yield();
+      }
+      // steps 5.3.1 and 5.3.2:
+      await this._hashAndTrackBlankNode({id, hashToBlankNodes});
+    }
 
-/***/ }),
+    // 5.4) For each hash to identifier list mapping in hash to blank
+    // nodes map, lexicographically-sorted by hash:
+    const hashes = [...hashToBlankNodes.keys()].sort();
+    // optimize away second sort, gather non-unique hashes in order as we go
+    const nonUnique = [];
+    for(const hash of hashes) {
+      // 5.4.1) If the length of identifier list is greater than 1,
+      // continue to the next mapping.
+      const idList = hashToBlankNodes.get(hash);
+      if(idList.length > 1) {
+        nonUnique.push(idList);
+        continue;
+      }
 
-/***/ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js":
-/*!****************************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/MessageDigest-browser.js ***!
-  \****************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+      // 5.4.2) Use the Issue Identifier algorithm, passing canonical
+      // issuer and the single blank node identifier in identifier
+      // list, identifier, to issue a canonical replacement identifier
+      // for identifier.
+      const id = idList[0];
+      this.canonicalIssuer.getId(id);
 
-"use strict";
-/*!
- * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
- */
+      // Note: These steps are skipped, optimized away since the loop
+      // only needs to be run once.
+      // 5.4.3) Remove identifier from non-normalized identifiers.
+      // 5.4.4) Remove hash from the hash to blank nodes map.
+      // 5.4.5) Set simple to true.
+    }
 
+    // 6) For each hash to identifier list mapping in hash to blank nodes map,
+    // lexicographically-sorted by hash:
+    // Note: sort optimized away, use `nonUnique`.
+    for(const idList of nonUnique) {
+      // 6.1) Create hash path list where each item will be a result of
+      // running the Hash N-Degree Quads algorithm.
+      const hashPathList = [];
 
-__webpack_require__(/*! setimmediate */ "./node_modules/setimmediate/setImmediate.js");
+      // 6.2) For each blank node identifier identifier in identifier list:
+      for(const id of idList) {
+        // 6.2.1) If a canonical identifier has already been issued for
+        // identifier, continue to the next identifier.
+        if(this.canonicalIssuer.hasId(id)) {
+          continue;
+        }
 
-const crypto = self.crypto || self.msCrypto;
+        // 6.2.2) Create temporary issuer, an identifier issuer
+        // initialized with the prefix _:b.
+        const issuer = new IdentifierIssuer('_:b');
 
-module.exports = class MessageDigest {
-  /**
-   * Creates a new MessageDigest.
-   *
-   * @param algorithm the algorithm to use.
-   */
-  constructor(algorithm) {
-    // check if crypto.subtle is available
-    // check is here rather than top-level to only fail if class is used
-    if(!(crypto && crypto.subtle)) {
-      throw new Error('crypto.subtle not found.');
-    }
-    if(algorithm === 'sha256') {
-      this.algorithm = {name: 'SHA-256'};
-    } else if(algorithm === 'sha1') {
-      this.algorithm = {name: 'SHA-1'};
-    } else {
-      throw new Error(`Unsupported algorithm "${algorithm}".`);
-    }
-    this._content = '';
-  }
+        // 6.2.3) Use the Issue Identifier algorithm, passing temporary
+        // issuer and identifier, to issue a new temporary blank node
+        // identifier for identifier.
+        issuer.getId(id);
 
-  update(msg) {
-    this._content += msg;
-  }
+        // 6.2.4) Run the Hash N-Degree Quads algorithm, passing
+        // temporary issuer, and append the result to the hash path list.
+        const result = await this.hashNDegreeQuads(id, issuer);
+        hashPathList.push(result);
+      }
 
-  async digest() {
-    const data = new TextEncoder().encode(this._content);
-    const buffer = new Uint8Array(
-      await crypto.subtle.digest(this.algorithm, data));
-    // return digest in hex
-    let hex = '';
-    for(let i = 0; i < buffer.length; ++i) {
-      hex += buffer[i].toString(16).padStart(2, '0');
+      // 6.3) For each result in the hash path list,
+      // lexicographically-sorted by the hash in result:
+      hashPathList.sort(_stringHashCompare);
+      for(const result of hashPathList) {
+        // 6.3.1) For each blank node identifier, existing identifier,
+        // that was issued a temporary identifier by identifier issuer
+        // in result, issue a canonical identifier, in the same order,
+        // using the Issue Identifier algorithm, passing canonical
+        // issuer and existing identifier.
+        const oldIds = result.issuer.getOldIds();
+        for(const id of oldIds) {
+          this.canonicalIssuer.getId(id);
+        }
+      }
     }
-    return hex;
-  }
-};
-
 
-/***/ }),
+    /* Note: At this point all blank nodes in the set of RDF quads have been
+    assigned canonical identifiers, which have been stored in the canonical
+    issuer. Here each quad is updated by assigning each of its blank nodes
+    its new identifier. */
 
-/***/ "./node_modules/rdf-canonize/lib/NQuads.js":
-/*!*************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/NQuads.js ***!
-  \*************************************************/
-/***/ ((module) => {
+    // 7) For each quad, quad, in input dataset:
+    const normalized = [];
+    for(const quad of this.quads) {
+      // 7.1) Create a copy, quad copy, of quad and replace any existing
+      // blank node identifiers using the canonical identifiers
+      // previously issued by canonical issuer.
+      // Note: We optimize away the copy here.
+      const nQuad = NQuads.serializeQuadComponents(
+        this._componentWithCanonicalId(quad.subject),
+        quad.predicate,
+        this._componentWithCanonicalId(quad.object),
+        this._componentWithCanonicalId(quad.graph)
+      );
+      // 7.2) Add quad copy to the normalized dataset.
+      normalized.push(nQuad);
+    }
 
-"use strict";
-/*!
- * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
- */
+    // sort normalized output
+    normalized.sort();
 
+    // 8) Return the normalized dataset.
+    return normalized.join('');
+  }
 
-// eslint-disable-next-line no-unused-vars
-const TERMS = ['subject', 'predicate', 'object', 'graph'];
-const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
-const RDF_LANGSTRING = RDF + 'langString';
-const XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
+  // 4.6) Hash First Degree Quads
+  async hashFirstDegreeQuads(id) {
+    // 1) Initialize nquads to an empty list. It will be used to store quads in
+    // N-Quads format.
+    const nquads = [];
 
-const TYPE_NAMED_NODE = 'NamedNode';
-const TYPE_BLANK_NODE = 'BlankNode';
-const TYPE_LITERAL = 'Literal';
-const TYPE_DEFAULT_GRAPH = 'DefaultGraph';
+    // 2) Get the list of quads `quads` associated with the reference blank node
+    // identifier in the blank node to quads map.
+    const info = this.blankNodeInfo.get(id);
+    const quads = info.quads;
 
-// build regexes
-const REGEX = {};
-(() => {
-  const iri = '(?:<([^:]+:[^>]*)>)';
-  // https://www.w3.org/TR/turtle/#grammar-production-BLANK_NODE_LABEL
-  const PN_CHARS_BASE =
-    'A-Z' + 'a-z' +
-    '\u00C0-\u00D6' +
-    '\u00D8-\u00F6' +
-    '\u00F8-\u02FF' +
-    '\u0370-\u037D' +
-    '\u037F-\u1FFF' +
-    '\u200C-\u200D' +
-    '\u2070-\u218F' +
-    '\u2C00-\u2FEF' +
-    '\u3001-\uD7FF' +
-    '\uF900-\uFDCF' +
-    '\uFDF0-\uFFFD';
-    // TODO:
-    //'\u10000-\uEFFFF';
-  const PN_CHARS_U =
-    PN_CHARS_BASE +
-    '_';
-  const PN_CHARS =
-    PN_CHARS_U +
-    '0-9' +
-    '-' +
-    '\u00B7' +
-    '\u0300-\u036F' +
-    '\u203F-\u2040';
-  const BLANK_NODE_LABEL =
-    '(_:' +
-      '(?:[' + PN_CHARS_U + '0-9])' +
-      '(?:(?:[' + PN_CHARS + '.])*(?:[' + PN_CHARS + ']))?' +
-    ')';
-  const bnode = BLANK_NODE_LABEL;
-  const plain = '"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"';
-  const datatype = '(?:\\^\\^' + iri + ')';
-  const language = '(?:@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*))';
-  const literal = '(?:' + plain + '(?:' + datatype + '|' + language + ')?)';
-  const ws = '[ \\t]+';
-  const wso = '[ \\t]*';
+    // 3) For each quad `quad` in `quads`:
+    for(const quad of quads) {
+      // 3.1) Serialize the quad in N-Quads format with the following special
+      // rule:
 
-  // define quad part regexes
-  const subject = '(?:' + iri + '|' + bnode + ')' + ws;
-  const property = iri + ws;
-  const object = '(?:' + iri + '|' + bnode + '|' + literal + ')' + wso;
-  const graphName = '(?:\\.|(?:(?:' + iri + '|' + bnode + ')' + wso + '\\.))';
+      // 3.1.1) If any component in quad is an blank node, then serialize it
+      // using a special identifier as follows:
+      const copy = {
+        subject: null, predicate: quad.predicate, object: null, graph: null
+      };
+      // 3.1.2) If the blank node's existing blank node identifier matches
+      // the reference blank node identifier then use the blank node
+      // identifier _:a, otherwise, use the blank node identifier _:z.
+      copy.subject = this.modifyFirstDegreeComponent(
+        id, quad.subject, 'subject');
+      copy.object = this.modifyFirstDegreeComponent(
+        id, quad.object, 'object');
+      copy.graph = this.modifyFirstDegreeComponent(
+        id, quad.graph, 'graph');
+      nquads.push(NQuads.serializeQuad(copy));
+    }
 
-  // end of line and empty regexes
-  REGEX.eoln = /(?:\r\n)|(?:\n)|(?:\r)/g;
-  REGEX.empty = new RegExp('^' + wso + '$');
+    // 4) Sort nquads in lexicographical order.
+    nquads.sort();
 
-  // full quad regex
-  REGEX.quad = new RegExp(
-    '^' + wso + subject + property + object + graphName + wso + '$');
-})();
+    // 5) Return the hash that results from passing the sorted, joined nquads
+    // through the hash algorithm.
+    const md = this.createMessageDigest();
+    for(const nquad of nquads) {
+      md.update(nquad);
+    }
+    info.hash = await md.digest();
+    return info.hash;
+  }
 
-module.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) {
-    // build RDF dataset
-    const dataset = [];
+  // 4.7) Hash Related Blank Node
+  async hashRelatedBlankNode(related, quad, issuer, position) {
+    // 1) Set the identifier to use for related, preferring first the canonical
+    // identifier for related if issued, second the identifier issued by issuer
+    // if issued, and last, if necessary, the result of the Hash First Degree
+    // Quads algorithm, passing related.
+    let id;
+    if(this.canonicalIssuer.hasId(related)) {
+      id = this.canonicalIssuer.getId(related);
+    } else if(issuer.hasId(related)) {
+      id = issuer.getId(related);
+    } else {
+      id = this.blankNodeInfo.get(related).hash;
+    }
 
-    const graphs = {};
+    // 2) Initialize a string input to the value of position.
+    // Note: We use a hash object instead.
+    const md = this.createMessageDigest();
+    md.update(position);
 
-    // split N-Quad input into lines
-    const lines = input.split(REGEX.eoln);
-    let lineNumber = 0;
-    for(const line of lines) {
-      lineNumber++;
+    // 3) If position is not g, append <, the value of the predicate in quad,
+    // and > to input.
+    if(position !== 'g') {
+      md.update(this.getRelatedPredicate(quad));
+    }
 
-      // skip empty lines
-      if(REGEX.empty.test(line)) {
-        continue;
-      }
+    // 4) Append identifier to input.
+    md.update(id);
 
-      // parse quad
-      const match = line.match(REGEX.quad);
-      if(match === null) {
-        throw new Error('N-Quads parse error on line ' + lineNumber + '.');
-      }
+    // 5) Return the hash that results from passing input through the hash
+    // algorithm.
+    return md.digest();
+  }
 
-      // create RDF quad
-      const quad = {subject: null, predicate: null, object: null, graph: null};
+  // 4.8) Hash N-Degree Quads
+  async hashNDegreeQuads(id, issuer) {
+    const deepIterations = this.deepIterations.get(id) || 0;
+    if(deepIterations > this.maxDeepIterations) {
+      throw new Error(
+        `Maximum deep iterations (${this.maxDeepIterations}) exceeded.`);
+    }
+    this.deepIterations.set(id, deepIterations + 1);
 
-      // get subject
-      if(match[1] !== undefined) {
-        quad.subject = {termType: TYPE_NAMED_NODE, value: match[1]};
-      } else {
-        quad.subject = {termType: TYPE_BLANK_NODE, value: match[2]};
-      }
+    // 1) Create a hash to related blank nodes map for storing hashes that
+    // identify related blank nodes.
+    // Note: 2) and 3) handled within `createHashToRelated`
+    const md = this.createMessageDigest();
+    const hashToRelated = await this.createHashToRelated(id, issuer);
 
-      // get predicate
-      quad.predicate = {termType: TYPE_NAMED_NODE, value: match[3]};
+    // 4) Create an empty string, data to hash.
+    // Note: We created a hash object `md` above instead.
 
-      // get object
-      if(match[4] !== undefined) {
-        quad.object = {termType: TYPE_NAMED_NODE, value: match[4]};
-      } else if(match[5] !== undefined) {
-        quad.object = {termType: TYPE_BLANK_NODE, value: match[5]};
-      } else {
-        quad.object = {
-          termType: TYPE_LITERAL,
-          value: undefined,
-          datatype: {
-            termType: TYPE_NAMED_NODE
-          }
-        };
-        if(match[7] !== undefined) {
-          quad.object.datatype.value = match[7];
-        } else if(match[8] !== undefined) {
-          quad.object.datatype.value = RDF_LANGSTRING;
-          quad.object.language = match[8];
-        } else {
-          quad.object.datatype.value = XSD_STRING;
-        }
-        quad.object.value = _unescape(match[6]);
-      }
+    // 5) For each related hash to blank node list mapping in hash to related
+    // blank nodes map, sorted lexicographically by related hash:
+    const hashes = [...hashToRelated.keys()].sort();
+    for(const hash of hashes) {
+      // 5.1) Append the related hash to the data to hash.
+      md.update(hash);
 
-      // get graph
-      if(match[9] !== undefined) {
-        quad.graph = {
-          termType: TYPE_NAMED_NODE,
-          value: match[9]
-        };
-      } else if(match[10] !== undefined) {
-        quad.graph = {
-          termType: TYPE_BLANK_NODE,
-          value: match[10]
-        };
-      } else {
-        quad.graph = {
-          termType: TYPE_DEFAULT_GRAPH,
-          value: ''
-        };
-      }
+      // 5.2) Create a string chosen path.
+      let chosenPath = '';
 
-      // only add quad if it is unique in its graph
-      if(!(quad.graph.value in graphs)) {
-        graphs[quad.graph.value] = [quad];
-        dataset.push(quad);
-      } else {
-        let unique = true;
-        const quads = graphs[quad.graph.value];
-        for(const q of quads) {
-          if(_compareTriples(q, quad)) {
-            unique = false;
-            break;
-          }
-        }
-        if(unique) {
-          quads.push(quad);
-          dataset.push(quad);
-        }
-      }
-    }
+      // 5.3) Create an unset chosen issuer variable.
+      let chosenIssuer;
 
-    return dataset;
-  }
+      // 5.4) For each permutation of blank node list:
+      const permuter = new Permuter(hashToRelated.get(hash));
+      let i = 0;
+      while(permuter.hasNext()) {
+        const permutation = permuter.next();
+        // Note: batch permutations 3 at a time
+        if(++i % 3 === 0) {
+          await this._yield();
+        }
 
-  /**
-   * 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);
-    }
-    const quads = [];
-    for(const quad of dataset) {
-      quads.push(NQuads.serializeQuad(quad));
-    }
-    return quads.sort().join('');
-  }
+        // 5.4.1) Create a copy of issuer, issuer copy.
+        let issuerCopy = issuer.clone();
 
-  /**
-   * 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 = '';
+        // 5.4.2) Create a string path.
+        let path = '';
 
-    // subject can only be NamedNode or BlankNode
-    if(s.termType === TYPE_NAMED_NODE) {
-      nquad += `<${s.value}>`;
-    } else {
-      nquad += `${s.value}`;
-    }
+        // 5.4.3) Create a recursion list, to store blank node identifiers
+        // that must be recursively processed by this algorithm.
+        const recursionList = [];
 
-    // predicate can only be NamedNode
-    nquad += ` <${p.value}> `;
+        // 5.4.4) For each related in permutation:
+        let nextPermutation = false;
+        for(const related of permutation) {
+          // 5.4.4.1) If a canonical identifier has been issued for
+          // related, append it to path.
+          if(this.canonicalIssuer.hasId(related)) {
+            path += this.canonicalIssuer.getId(related);
+          } else {
+            // 5.4.4.2) Otherwise:
+            // 5.4.4.2.1) If issuer copy has not issued an identifier for
+            // related, append related to recursion list.
+            if(!issuerCopy.hasId(related)) {
+              recursionList.push(related);
+            }
+            // 5.4.4.2.2) Use the Issue Identifier algorithm, passing
+            // issuer copy and related and append the result to path.
+            path += issuerCopy.getId(related);
+          }
 
-    // object is NamedNode, BlankNode, or Literal
-    if(o.termType === TYPE_NAMED_NODE) {
-      nquad += `<${o.value}>`;
-    } else if(o.termType === TYPE_BLANK_NODE) {
-      nquad += o.value;
-    } else {
-      nquad += `"${_escape(o.value)}"`;
-      if(o.datatype.value === RDF_LANGSTRING) {
-        if(o.language) {
-          nquad += `@${o.language}`;
+          // 5.4.4.3) If chosen path is not empty and the length of path
+          // is greater than or equal to the length of chosen path and
+          // path is lexicographically greater than chosen path, then
+          // skip to the next permutation.
+          // Note: Comparing path length to chosen path length can be optimized
+          // away; only compare lexicographically.
+          if(chosenPath.length !== 0 && path > chosenPath) {
+            nextPermutation = true;
+            break;
+          }
         }
-      } else if(o.datatype.value !== XSD_STRING) {
-        nquad += `^^<${o.datatype.value}>`;
-      }
-    }
 
-    // graph can only be NamedNode or BlankNode (or DefaultGraph, but that
-    // does not add to `nquad`)
-    if(g.termType === TYPE_NAMED_NODE) {
-      nquad += ` <${g.value}>`;
-    } else if(g.termType === TYPE_BLANK_NODE) {
-      nquad += ` ${g.value}`;
-    }
+        if(nextPermutation) {
+          continue;
+        }
 
-    nquad += ' .\n';
-    return nquad;
-  }
+        // 5.4.5) For each related in recursion list:
+        for(const related of recursionList) {
+          // 5.4.5.1) Set result to the result of recursively executing
+          // the Hash N-Degree Quads algorithm, passing related for
+          // identifier and issuer copy for path identifier issuer.
+          const result = await this.hashNDegreeQuads(related, issuerCopy);
 
-  /**
-   * 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(quad) {
-    return NQuads.serializeQuadComponents(
-      quad.subject, quad.predicate, quad.object, quad.graph);
-  }
+          // 5.4.5.2) Use the Issue Identifier algorithm, passing issuer
+          // copy and related and append the result to path.
+          path += issuerCopy.getId(related);
 
-  /**
-   * 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 = [];
+          // 5.4.5.3) Append <, the hash in result, and > to path.
+          path += `<${result.hash}>`;
 
-    const termTypeMap = {
-      'blank node': TYPE_BLANK_NODE,
-      IRI: TYPE_NAMED_NODE,
-      literal: TYPE_LITERAL
-    };
+          // 5.4.5.4) Set issuer copy to the identifier issuer in
+          // result.
+          issuerCopy = result.issuer;
 
-    for(const graphName in dataset) {
-      const triples = dataset[graphName];
-      triples.forEach(triple => {
-        const quad = {};
-        for(const componentName in triple) {
-          const oldComponent = triple[componentName];
-          const newComponent = {
-            termType: termTypeMap[oldComponent.type],
-            value: oldComponent.value
-          };
-          if(newComponent.termType === TYPE_LITERAL) {
-            newComponent.datatype = {
-              termType: TYPE_NAMED_NODE
-            };
-            if('datatype' in oldComponent) {
-              newComponent.datatype.value = oldComponent.datatype;
-            }
-            if('language' in oldComponent) {
-              if(!('datatype' in oldComponent)) {
-                newComponent.datatype.value = RDF_LANGSTRING;
-              }
-              newComponent.language = oldComponent.language;
-            } else if(!('datatype' in oldComponent)) {
-              newComponent.datatype.value = XSD_STRING;
-            }
+          // 5.4.5.5) If chosen path is not empty and the length of path
+          // is greater than or equal to the length of chosen path and
+          // path is lexicographically greater than chosen path, then
+          // skip to the next permutation.
+          // Note: Comparing path length to chosen path length can be optimized
+          // away; only compare lexicographically.
+          if(chosenPath.length !== 0 && path > chosenPath) {
+            nextPermutation = true;
+            break;
           }
-          quad[componentName] = newComponent;
         }
-        if(graphName === '@default') {
-          quad.graph = {
-            termType: TYPE_DEFAULT_GRAPH,
-            value: ''
-          };
-        } else {
-          quad.graph = {
-            termType: graphName.startsWith('_:') ?
-              TYPE_BLANK_NODE : TYPE_NAMED_NODE,
-            value: graphName
-          };
-        }
-        quads.push(quad);
-      });
-    }
 
-    return quads;
-  }
-};
+        if(nextPermutation) {
+          continue;
+        }
 
-/**
- * Compares two RDF triples for equality.
- *
- * @param t1 the first triple.
- * @param t2 the second triple.
- *
- * @return true if the triples are the same, false if not.
- */
-function _compareTriples(t1, t2) {
-  // compare subject and object types first as it is the quickest check
-  if(!(t1.subject.termType === t2.subject.termType &&
-    t1.object.termType === t2.object.termType)) {
-    return false;
-  }
-  // compare values
-  if(!(t1.subject.value === t2.subject.value &&
-    t1.predicate.value === t2.predicate.value &&
-    t1.object.value === t2.object.value)) {
-    return false;
-  }
-  if(t1.object.termType !== TYPE_LITERAL) {
-    // no `datatype` or `language` to check
-    return true;
-  }
-  return (
-    (t1.object.datatype.termType === t2.object.datatype.termType) &&
-    (t1.object.language === t2.object.language) &&
-    (t1.object.datatype.value === t2.object.datatype.value)
-  );
-}
+        // 5.4.6) If chosen path is empty or path is lexicographically
+        // less than chosen path, set chosen path to path and chosen
+        // issuer to issuer copy.
+        if(chosenPath.length === 0 || path < chosenPath) {
+          chosenPath = path;
+          chosenIssuer = issuerCopy;
+        }
+      }
 
-const _escapeRegex = /["\\\n\r]/g;
-/**
- * Escape string to N-Quads literal
- */
-function _escape(s) {
-  return s.replace(_escapeRegex, function(match) {
-    switch(match) {
-      case '"': return '\\"';
-      case '\\': return '\\\\';
-      case '\n': return '\\n';
-      case '\r': return '\\r';
-    }
-  });
-}
+      // 5.5) Append chosen path to data to hash.
+      md.update(chosenPath);
 
-const _unescapeRegex =
-  /(?:\\([tbnrf"'\\]))|(?:\\u([0-9A-Fa-f]{4}))|(?:\\U([0-9A-Fa-f]{8}))/g;
-/**
- * Unescape N-Quads literal to string
- */
-function _unescape(s) {
-  return s.replace(_unescapeRegex, function(match, code, u, U) {
-    if(code) {
-      switch(code) {
-        case 't': return '\t';
-        case 'b': return '\b';
-        case 'n': return '\n';
-        case 'r': return '\r';
-        case 'f': return '\f';
-        case '"': return '"';
-        case '\'': return '\'';
-        case '\\': return '\\';
-      }
-    }
-    if(u) {
-      return String.fromCharCode(parseInt(u, 16));
-    }
-    if(U) {
-      // FIXME: support larger values
-      throw new Error('Unsupported U escape');
+      // 5.6) Replace issuer, by reference, with chosen issuer.
+      issuer = chosenIssuer;
     }
-  });
-}
 
+    // 6) Return issuer and the hash that results from passing data to hash
+    // through the hash algorithm.
+    return {hash: await md.digest(), issuer};
+  }
 
-/***/ }),
+  // helper for modifying component during Hash First Degree Quads
+  modifyFirstDegreeComponent(id, component) {
+    if(component.termType !== 'BlankNode') {
+      return component;
+    }
+    /* Note: A mistake in the URDNA2015 spec that made its way into
+    implementations (and therefore must stay to avoid interop breakage)
+    resulted in an assigned canonical ID, if available for
+    `component.value`, not being used in place of `_:a`/`_:z`, so
+    we don't use it here. */
+    return {
+      termType: 'BlankNode',
+      value: component.value === id ? '_:a' : '_:z'
+    };
+  }
 
-/***/ "./node_modules/rdf-canonize/lib/Permuter.js":
-/*!***************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/Permuter.js ***!
-  \***************************************************/
-/***/ ((module) => {
+  // helper for getting a related predicate
+  getRelatedPredicate(quad) {
+    return `<${quad.predicate.value}>`;
+  }
 
-"use strict";
-/*!
- * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
- */
+  // helper for creating hash to related blank nodes map
+  async createHashToRelated(id, issuer) {
+    // 1) Create a hash to related blank nodes map for storing hashes that
+    // identify related blank nodes.
+    const hashToRelated = new Map();
 
+    // 2) Get a reference, quads, to the list of quads in the blank node to
+    // quads map for the key identifier.
+    const quads = this.blankNodeInfo.get(id).quads;
 
-module.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) {
-    // original array
-    this.current = list.sort();
-    // indicates whether there are more permutations
-    this.done = false;
-    // directional info for permutation algorithm
-    this.dir = new Map();
-    for(let i = 0; i < list.length; ++i) {
-      this.dir.set(list[i], true);
+    // 3) For each quad in quads:
+    let i = 0;
+    for(const quad of quads) {
+      // Note: batch hashing related blank node quads 100 at a time
+      if(++i % 100 === 0) {
+        await this._yield();
+      }
+      // 3.1) For each component in quad, if component is the subject, object,
+      // and graph name and it is a blank node that is not identified by
+      // identifier:
+      // steps 3.1.1 and 3.1.2 occur in helpers:
+      await Promise.all([
+        this._addRelatedBlankNodeHash({
+          quad, component: quad.subject, position: 's',
+          id, issuer, hashToRelated
+        }),
+        this._addRelatedBlankNodeHash({
+          quad, component: quad.object, position: 'o',
+          id, issuer, hashToRelated
+        }),
+        this._addRelatedBlankNodeHash({
+          quad, component: quad.graph, position: 'g',
+          id, issuer, hashToRelated
+        })
+      ]);
     }
-  }
 
-  /**
-   * Returns true if there is another permutation.
-   *
-   * @return true if there is another permutation, false if not.
-   */
-  hasNext() {
-    return !this.done;
+    return hashToRelated;
   }
 
-  /**
-   * Gets the next permutation. Call hasNext() to ensure there is another one
-   * first.
-   *
-   * @return the next permutation.
-   */
-  next() {
-    // copy current permutation to return it
-    const {current, dir} = this;
-    const rval = current.slice();
+  async _hashAndTrackBlankNode({id, hashToBlankNodes}) {
+    // 5.3.1) Create a hash, hash, according to the Hash First Degree
+    // Quads algorithm.
+    const hash = await this.hashFirstDegreeQuads(id);
 
-    /* Calculate the next permutation using the Steinhaus-Johnson-Trotter
-     permutation algorithm. */
+    // 5.3.2) Add hash and identifier to hash to blank nodes map,
+    // creating a new entry if necessary.
+    const idList = hashToBlankNodes.get(hash);
+    if(!idList) {
+      hashToBlankNodes.set(hash, [id]);
+    } else {
+      idList.push(id);
+    }
+  }
 
-    // get largest mobile element k
-    // (mobile: element is greater than the one it is looking at)
-    let k = null;
-    let pos = 0;
-    const length = current.length;
-    for(let i = 0; i < length; ++i) {
-      const element = current[i];
-      const left = dir.get(element);
-      if((k === null || element > k) &&
-        ((left && i > 0 && element > current[i - 1]) ||
-        (!left && i < (length - 1) && element > current[i + 1]))) {
-        k = element;
-        pos = i;
-      }
+  _addBlankNodeQuadInfo({quad, component}) {
+    if(component.termType !== 'BlankNode') {
+      return;
+    }
+    const id = component.value;
+    const info = this.blankNodeInfo.get(id);
+    if(info) {
+      info.quads.add(quad);
+    } else {
+      this.blankNodeInfo.set(id, {quads: new Set([quad]), hash: null});
     }
+  }
 
-    // no more permutations
-    if(k === null) {
-      this.done = true;
+  async _addRelatedBlankNodeHash(
+    {quad, component, position, id, issuer, hashToRelated}) {
+    if(!(component.termType === 'BlankNode' && component.value !== id)) {
+      return;
+    }
+    // 3.1.1) Set hash to the result of the Hash Related Blank Node
+    // algorithm, passing the blank node identifier for component as
+    // related, quad, path identifier issuer as issuer, and position as
+    // either s, o, or g based on whether component is a subject, object,
+    // graph name, respectively.
+    const related = component.value;
+    const hash = await this.hashRelatedBlankNode(
+      related, quad, issuer, position);
+
+    // 3.1.2) Add a mapping of hash to the blank node identifier for
+    // component to hash to related blank nodes map, adding an entry as
+    // necessary.
+    const entries = hashToRelated.get(hash);
+    if(entries) {
+      entries.push(related);
     } else {
-      // swap k and the element it is looking at
-      const swap = dir.get(k) ? pos - 1 : pos + 1;
-      current[pos] = current[swap];
-      current[swap] = k;
+      hashToRelated.set(hash, [related]);
+    }
+  }
 
-      // reverse the direction of all elements larger than k
-      for(const element of current) {
-        if(element > k) {
-          dir.set(element, !dir.get(element));
-        }
-      }
+  // canonical ids for 7.1
+  _componentWithCanonicalId(component) {
+    if(component.termType === 'BlankNode' &&
+      !component.value.startsWith(this.canonicalIssuer.prefix)) {
+      // create new BlankNode
+      return {
+        termType: 'BlankNode',
+        value: this.canonicalIssuer.getId(component.value)
+      };
     }
+    return component;
+  }
 
-    return rval;
+  async _yield() {
+    return new Promise(resolve => setImmediate(resolve));
   }
 };
 
+function _stringHashCompare(a, b) {
+  return a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0;
+}
+
 
 /***/ }),
 
-/***/ "./node_modules/rdf-canonize/lib/URDNA2015.js":
-/*!****************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/URDNA2015.js ***!
-  \****************************************************/
+/***/ "./node_modules/rdf-canonize/lib/URDNA2015Sync.js":
+/*!********************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/URDNA2015Sync.js ***!
+  \********************************************************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
@@ -10503,11 +10585,13 @@ module.exports = class Permuter {
 
 
 const IdentifierIssuer = __webpack_require__(/*! ./IdentifierIssuer */ "./node_modules/rdf-canonize/lib/IdentifierIssuer.js");
+// FIXME: do not import; convert to requiring a
+// hash factory
 const MessageDigest = __webpack_require__(/*! ./MessageDigest */ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js");
 const Permuter = __webpack_require__(/*! ./Permuter */ "./node_modules/rdf-canonize/lib/Permuter.js");
 const NQuads = __webpack_require__(/*! ./NQuads */ "./node_modules/rdf-canonize/lib/NQuads.js");
 
-module.exports = class URDNA2015 {
+module.exports = class URDNA2015Sync {
   constructor({
     createMessageDigest = () => new MessageDigest('sha256'),
     maxDeepIterations = Infinity
@@ -10522,7 +10606,7 @@ module.exports = class URDNA2015 {
   }
 
   // 4.4) Normalization Algorithm
-  async main(dataset) {
+  main(dataset) {
     this.deepIterations = new Map();
     this.quads = dataset;
 
@@ -10554,14 +10638,9 @@ module.exports = class URDNA2015 {
     // identifiers:
     const hashToBlankNodes = new Map();
     const nonNormalized = [...this.blankNodeInfo.keys()];
-    let i = 0;
     for(const id of nonNormalized) {
-      // Note: batch hashing first degree quads 100 at a time
-      if(++i % 100 === 0) {
-        await this._yield();
-      }
       // steps 5.3.1 and 5.3.2:
-      await this._hashAndTrackBlankNode({id, hashToBlankNodes});
+      this._hashAndTrackBlankNode({id, hashToBlankNodes});
     }
 
     // 5.4) For each hash to identifier list mapping in hash to blank
@@ -10619,7 +10698,7 @@ module.exports = class URDNA2015 {
 
         // 6.2.4) Run the Hash N-Degree Quads algorithm, passing
         // temporary issuer, and append the result to the hash path list.
-        const result = await this.hashNDegreeQuads(id, issuer);
+        const result = this.hashNDegreeQuads(id, issuer);
         hashPathList.push(result);
       }
 
@@ -10652,10 +10731,10 @@ module.exports = class URDNA2015 {
       // previously issued by canonical issuer.
       // Note: We optimize away the copy here.
       const nQuad = NQuads.serializeQuadComponents(
-        this._componentWithCanonicalId(quad.subject),
+        this._componentWithCanonicalId({component: quad.subject}),
         quad.predicate,
-        this._componentWithCanonicalId(quad.object),
-        this._componentWithCanonicalId(quad.graph)
+        this._componentWithCanonicalId({component: quad.object}),
+        this._componentWithCanonicalId({component: quad.graph})
       );
       // 7.2) Add quad copy to the normalized dataset.
       normalized.push(nQuad);
@@ -10669,7 +10748,7 @@ module.exports = class URDNA2015 {
   }
 
   // 4.6) Hash First Degree Quads
-  async hashFirstDegreeQuads(id) {
+  hashFirstDegreeQuads(id) {
     // 1) Initialize nquads to an empty list. It will be used to store quads in
     // N-Quads format.
     const nquads = [];
@@ -10710,12 +10789,12 @@ module.exports = class URDNA2015 {
     for(const nquad of nquads) {
       md.update(nquad);
     }
-    info.hash = await md.digest();
+    info.hash = md.digest();
     return info.hash;
   }
 
   // 4.7) Hash Related Blank Node
-  async hashRelatedBlankNode(related, quad, issuer, position) {
+  hashRelatedBlankNode(related, quad, issuer, position) {
     // 1) Set the identifier to use for related, preferring first the canonical
     // identifier for related if issued, second the identifier issued by issuer
     // if issued, and last, if necessary, the result of the Hash First Degree
@@ -10749,7 +10828,7 @@ module.exports = class URDNA2015 {
   }
 
   // 4.8) Hash N-Degree Quads
-  async hashNDegreeQuads(id, issuer) {
+  hashNDegreeQuads(id, issuer) {
     const deepIterations = this.deepIterations.get(id) || 0;
     if(deepIterations > this.maxDeepIterations) {
       throw new Error(
@@ -10761,7 +10840,7 @@ module.exports = class URDNA2015 {
     // identify related blank nodes.
     // Note: 2) and 3) handled within `createHashToRelated`
     const md = this.createMessageDigest();
-    const hashToRelated = await this.createHashToRelated(id, issuer);
+    const hashToRelated = this.createHashToRelated(id, issuer);
 
     // 4) Create an empty string, data to hash.
     // Note: We created a hash object `md` above instead.
@@ -10781,13 +10860,8 @@ module.exports = class URDNA2015 {
 
       // 5.4) For each permutation of blank node list:
       const permuter = new Permuter(hashToRelated.get(hash));
-      let i = 0;
       while(permuter.hasNext()) {
         const permutation = permuter.next();
-        // Note: batch permutations 3 at a time
-        if(++i % 3 === 0) {
-          await this._yield();
-        }
 
         // 5.4.1) Create a copy of issuer, issuer copy.
         let issuerCopy = issuer.clone();
@@ -10839,7 +10913,7 @@ module.exports = class URDNA2015 {
           // 5.4.5.1) Set result to the result of recursively executing
           // the Hash N-Degree Quads algorithm, passing related for
           // identifier and issuer copy for path identifier issuer.
-          const result = await this.hashNDegreeQuads(related, issuerCopy);
+          const result = this.hashNDegreeQuads(related, issuerCopy);
 
           // 5.4.5.2) Use the Issue Identifier algorithm, passing issuer
           // copy and related and append the result to path.
@@ -10886,7 +10960,7 @@ module.exports = class URDNA2015 {
 
     // 6) Return issuer and the hash that results from passing data to hash
     // through the hash algorithm.
-    return {hash: await md.digest(), issuer};
+    return {hash: md.digest(), issuer};
   }
 
   // helper for modifying component during Hash First Degree Quads
@@ -10911,7 +10985,7 @@ module.exports = class URDNA2015 {
   }
 
   // helper for creating hash to related blank nodes map
-  async createHashToRelated(id, issuer) {
+  createHashToRelated(id, issuer) {
     // 1) Create a hash to related blank nodes map for storing hashes that
     // identify related blank nodes.
     const hashToRelated = new Map();
@@ -10921,39 +10995,32 @@ module.exports = class URDNA2015 {
     const quads = this.blankNodeInfo.get(id).quads;
 
     // 3) For each quad in quads:
-    let i = 0;
     for(const quad of quads) {
-      // Note: batch hashing related blank node quads 100 at a time
-      if(++i % 100 === 0) {
-        await this._yield();
-      }
       // 3.1) For each component in quad, if component is the subject, object,
-      // and graph name and it is a blank node that is not identified by
+      // or graph name and it is a blank node that is not identified by
       // identifier:
       // steps 3.1.1 and 3.1.2 occur in helpers:
-      await Promise.all([
-        this._addRelatedBlankNodeHash({
-          quad, component: quad.subject, position: 's',
-          id, issuer, hashToRelated
-        }),
-        this._addRelatedBlankNodeHash({
-          quad, component: quad.object, position: 'o',
-          id, issuer, hashToRelated
-        }),
-        this._addRelatedBlankNodeHash({
-          quad, component: quad.graph, position: 'g',
-          id, issuer, hashToRelated
-        })
-      ]);
+      this._addRelatedBlankNodeHash({
+        quad, component: quad.subject, position: 's',
+        id, issuer, hashToRelated
+      });
+      this._addRelatedBlankNodeHash({
+        quad, component: quad.object, position: 'o',
+        id, issuer, hashToRelated
+      });
+      this._addRelatedBlankNodeHash({
+        quad, component: quad.graph, position: 'g',
+        id, issuer, hashToRelated
+      });
     }
 
     return hashToRelated;
   }
 
-  async _hashAndTrackBlankNode({id, hashToBlankNodes}) {
+  _hashAndTrackBlankNode({id, hashToBlankNodes}) {
     // 5.3.1) Create a hash, hash, according to the Hash First Degree
     // Quads algorithm.
-    const hash = await this.hashFirstDegreeQuads(id);
+    const hash = this.hashFirstDegreeQuads(id);
 
     // 5.3.2) Add hash and identifier to hash to blank nodes map,
     // creating a new entry if necessary.
@@ -10978,7 +11045,7 @@ module.exports = class URDNA2015 {
     }
   }
 
-  async _addRelatedBlankNodeHash(
+  _addRelatedBlankNodeHash(
     {quad, component, position, id, issuer, hashToRelated}) {
     if(!(component.termType === 'BlankNode' && component.value !== id)) {
       return;
@@ -10989,8 +11056,7 @@ module.exports = class URDNA2015 {
     // either s, o, or g based on whether component is a subject, object,
     // graph name, respectively.
     const related = component.value;
-    const hash = await this.hashRelatedBlankNode(
-      related, quad, issuer, position);
+    const hash = this.hashRelatedBlankNode(related, quad, issuer, position);
 
     // 3.1.2) Add a mapping of hash to the blank node identifier for
     // component to hash to related blank nodes map, adding an entry as
@@ -11004,1128 +11070,1062 @@ module.exports = class URDNA2015 {
   }
 
   // canonical ids for 7.1
-  _componentWithCanonicalId(component) {
+  _componentWithCanonicalId({component}) {
     if(component.termType === 'BlankNode' &&
       !component.value.startsWith(this.canonicalIssuer.prefix)) {
       // create new BlankNode
       return {
         termType: 'BlankNode',
-        value: this.canonicalIssuer.getId(component.value)
+        value: this.canonicalIssuer.getId(component.value)
+      };
+    }
+    return component;
+  }
+};
+
+function _stringHashCompare(a, b) {
+  return a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0;
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/rdf-canonize/lib/URGNA2012.js":
+/*!****************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/URGNA2012.js ***!
+  \****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/*!
+ * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+
+
+const MessageDigest = __webpack_require__(/*! ./MessageDigest */ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js");
+const URDNA2015 = __webpack_require__(/*! ./URDNA2015 */ "./node_modules/rdf-canonize/lib/URDNA2015.js");
+
+module.exports = class URDNA2012 extends URDNA2015 {
+  constructor() {
+    super();
+    this.name = 'URGNA2012';
+    this.createMessageDigest = () => new MessageDigest('sha1');
+  }
+
+  // helper for modifying component during Hash First Degree Quads
+  modifyFirstDegreeComponent(id, component, key) {
+    if(component.termType !== 'BlankNode') {
+      return component;
+    }
+    if(key === 'graph') {
+      return {
+        termType: 'BlankNode',
+        value: '_:g'
       };
     }
-    return component;
+    return {
+      termType: 'BlankNode',
+      value: (component.value === id ? '_:a' : '_:z')
+    };
   }
 
-  async _yield() {
-    return new Promise(resolve => setImmediate(resolve));
+  // helper for getting a related predicate
+  getRelatedPredicate(quad) {
+    return quad.predicate.value;
   }
-};
 
-function _stringHashCompare(a, b) {
-  return a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0;
-}
+  // helper for creating hash to related blank nodes map
+  async createHashToRelated(id, issuer) {
+    // 1) Create a hash to related blank nodes map for storing hashes that
+    // identify related blank nodes.
+    const hashToRelated = new Map();
+
+    // 2) Get a reference, quads, to the list of quads in the blank node to
+    // quads map for the key identifier.
+    const quads = this.blankNodeInfo.get(id).quads;
+
+    // 3) For each quad in quads:
+    let i = 0;
+    for(const quad of quads) {
+      // 3.1) If the quad's subject is a blank node that does not match
+      // identifier, set hash to the result of the Hash Related Blank Node
+      // algorithm, passing the blank node identifier for subject as related,
+      // quad, path identifier issuer as issuer, and p as position.
+      let position;
+      let related;
+      if(quad.subject.termType === 'BlankNode' && quad.subject.value !== id) {
+        related = quad.subject.value;
+        position = 'p';
+      } else if(
+        quad.object.termType === 'BlankNode' && quad.object.value !== id) {
+        // 3.2) Otherwise, if quad's object is a blank node that does not match
+        // identifier, to the result of the Hash Related Blank Node algorithm,
+        // passing the blank node identifier for object as related, quad, path
+        // identifier issuer as issuer, and r as position.
+        related = quad.object.value;
+        position = 'r';
+      } else {
+        // 3.3) Otherwise, continue to the next quad.
+        continue;
+      }
+      // Note: batch hashing related blank nodes 100 at a time
+      if(++i % 100 === 0) {
+        await this._yield();
+      }
+      // 3.4) Add a mapping of hash to the blank node identifier for the
+      // component that matched (subject or object) to hash to related blank
+      // nodes map, adding an entry as necessary.
+      const hash = await this.hashRelatedBlankNode(
+        related, quad, issuer, position);
+      const entries = hashToRelated.get(hash);
+      if(entries) {
+        entries.push(related);
+      } else {
+        hashToRelated.set(hash, [related]);
+      }
+    }
+
+    return hashToRelated;
+  }
+};
 
 
 /***/ }),
 
-/***/ "./node_modules/rdf-canonize/lib/URDNA2015Sync.js":
+/***/ "./node_modules/rdf-canonize/lib/URGNA2012Sync.js":
 /*!********************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/URDNA2015Sync.js ***!
+  !*** ./node_modules/rdf-canonize/lib/URGNA2012Sync.js ***!
   \********************************************************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 /*!
- * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2016-2021 Digital Bazaar, Inc. All rights reserved.
  */
 
 
-const IdentifierIssuer = __webpack_require__(/*! ./IdentifierIssuer */ "./node_modules/rdf-canonize/lib/IdentifierIssuer.js");
-// FIXME: do not import; convert to requiring a
-// hash factory
 const MessageDigest = __webpack_require__(/*! ./MessageDigest */ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js");
-const Permuter = __webpack_require__(/*! ./Permuter */ "./node_modules/rdf-canonize/lib/Permuter.js");
-const NQuads = __webpack_require__(/*! ./NQuads */ "./node_modules/rdf-canonize/lib/NQuads.js");
+const URDNA2015Sync = __webpack_require__(/*! ./URDNA2015Sync */ "./node_modules/rdf-canonize/lib/URDNA2015Sync.js");
 
-module.exports = class URDNA2015Sync {
-  constructor({
-    createMessageDigest = () => new MessageDigest('sha256'),
-    maxDeepIterations = Infinity
-  } = {}) {
-    this.name = 'URDNA2015';
-    this.blankNodeInfo = new Map();
-    this.canonicalIssuer = new IdentifierIssuer('_:c14n');
-    this.createMessageDigest = createMessageDigest;
-    this.maxDeepIterations = maxDeepIterations;
-    this.quads = null;
-    this.deepIterations = null;
+module.exports = class URDNA2012Sync extends URDNA2015Sync {
+  constructor() {
+    super();
+    this.name = 'URGNA2012';
+    this.createMessageDigest = () => new MessageDigest('sha1');
   }
 
-  // 4.4) Normalization Algorithm
-  main(dataset) {
-    this.deepIterations = new Map();
-    this.quads = dataset;
-
-    // 1) Create the normalization state.
-    // 2) For every quad in input dataset:
-    for(const quad of dataset) {
-      // 2.1) For each blank node that occurs in the quad, add a reference
-      // to the quad using the blank node identifier in the blank node to
-      // quads map, creating a new entry if necessary.
-      this._addBlankNodeQuadInfo({quad, component: quad.subject});
-      this._addBlankNodeQuadInfo({quad, component: quad.object});
-      this._addBlankNodeQuadInfo({quad, component: quad.graph});
-    }
-
-    // 3) Create a list of non-normalized blank node identifiers
-    // non-normalized identifiers and populate it using the keys from the
-    // blank node to quads map.
-    // Note: We use a map here and it was generated during step 2.
-
-    // 4) `simple` flag is skipped -- loop is optimized away. This optimization
-    // is permitted because there was a typo in the hash first degree quads
-    // algorithm in the URDNA2015 spec that was implemented widely making it
-    // such that it could not be fixed; the result was that the loop only
-    // needs to be run once and the first degree quad hashes will never change.
-    // 5.1-5.2 are skipped; first degree quad hashes are generated just once
-    // for all non-normalized blank nodes.
-
-    // 5.3) For each blank node identifier identifier in non-normalized
-    // identifiers:
-    const hashToBlankNodes = new Map();
-    const nonNormalized = [...this.blankNodeInfo.keys()];
-    for(const id of nonNormalized) {
-      // steps 5.3.1 and 5.3.2:
-      this._hashAndTrackBlankNode({id, hashToBlankNodes});
+  // helper for modifying component during Hash First Degree Quads
+  modifyFirstDegreeComponent(id, component, key) {
+    if(component.termType !== 'BlankNode') {
+      return component;
     }
-
-    // 5.4) For each hash to identifier list mapping in hash to blank
-    // nodes map, lexicographically-sorted by hash:
-    const hashes = [...hashToBlankNodes.keys()].sort();
-    // optimize away second sort, gather non-unique hashes in order as we go
-    const nonUnique = [];
-    for(const hash of hashes) {
-      // 5.4.1) If the length of identifier list is greater than 1,
-      // continue to the next mapping.
-      const idList = hashToBlankNodes.get(hash);
-      if(idList.length > 1) {
-        nonUnique.push(idList);
-        continue;
-      }
-
-      // 5.4.2) Use the Issue Identifier algorithm, passing canonical
-      // issuer and the single blank node identifier in identifier
-      // list, identifier, to issue a canonical replacement identifier
-      // for identifier.
-      const id = idList[0];
-      this.canonicalIssuer.getId(id);
-
-      // Note: These steps are skipped, optimized away since the loop
-      // only needs to be run once.
-      // 5.4.3) Remove identifier from non-normalized identifiers.
-      // 5.4.4) Remove hash from the hash to blank nodes map.
-      // 5.4.5) Set simple to true.
+    if(key === 'graph') {
+      return {
+        termType: 'BlankNode',
+        value: '_:g'
+      };
     }
+    return {
+      termType: 'BlankNode',
+      value: (component.value === id ? '_:a' : '_:z')
+    };
+  }
 
-    // 6) For each hash to identifier list mapping in hash to blank nodes map,
-    // lexicographically-sorted by hash:
-    // Note: sort optimized away, use `nonUnique`.
-    for(const idList of nonUnique) {
-      // 6.1) Create hash path list where each item will be a result of
-      // running the Hash N-Degree Quads algorithm.
-      const hashPathList = [];
-
-      // 6.2) For each blank node identifier identifier in identifier list:
-      for(const id of idList) {
-        // 6.2.1) If a canonical identifier has already been issued for
-        // identifier, continue to the next identifier.
-        if(this.canonicalIssuer.hasId(id)) {
-          continue;
-        }
+  // helper for getting a related predicate
+  getRelatedPredicate(quad) {
+    return quad.predicate.value;
+  }
 
-        // 6.2.2) Create temporary issuer, an identifier issuer
-        // initialized with the prefix _:b.
-        const issuer = new IdentifierIssuer('_:b');
+  // helper for creating hash to related blank nodes map
+  createHashToRelated(id, issuer) {
+    // 1) Create a hash to related blank nodes map for storing hashes that
+    // identify related blank nodes.
+    const hashToRelated = new Map();
 
-        // 6.2.3) Use the Issue Identifier algorithm, passing temporary
-        // issuer and identifier, to issue a new temporary blank node
-        // identifier for identifier.
-        issuer.getId(id);
+    // 2) Get a reference, quads, to the list of quads in the blank node to
+    // quads map for the key identifier.
+    const quads = this.blankNodeInfo.get(id).quads;
 
-        // 6.2.4) Run the Hash N-Degree Quads algorithm, passing
-        // temporary issuer, and append the result to the hash path list.
-        const result = this.hashNDegreeQuads(id, issuer);
-        hashPathList.push(result);
+    // 3) For each quad in quads:
+    for(const quad of quads) {
+      // 3.1) If the quad's subject is a blank node that does not match
+      // identifier, set hash to the result of the Hash Related Blank Node
+      // algorithm, passing the blank node identifier for subject as related,
+      // quad, path identifier issuer as issuer, and p as position.
+      let position;
+      let related;
+      if(quad.subject.termType === 'BlankNode' && quad.subject.value !== id) {
+        related = quad.subject.value;
+        position = 'p';
+      } else if(
+        quad.object.termType === 'BlankNode' && quad.object.value !== id) {
+        // 3.2) Otherwise, if quad's object is a blank node that does not match
+        // identifier, to the result of the Hash Related Blank Node algorithm,
+        // passing the blank node identifier for object as related, quad, path
+        // identifier issuer as issuer, and r as position.
+        related = quad.object.value;
+        position = 'r';
+      } else {
+        // 3.3) Otherwise, continue to the next quad.
+        continue;
       }
-
-      // 6.3) For each result in the hash path list,
-      // lexicographically-sorted by the hash in result:
-      hashPathList.sort(_stringHashCompare);
-      for(const result of hashPathList) {
-        // 6.3.1) For each blank node identifier, existing identifier,
-        // that was issued a temporary identifier by identifier issuer
-        // in result, issue a canonical identifier, in the same order,
-        // using the Issue Identifier algorithm, passing canonical
-        // issuer and existing identifier.
-        const oldIds = result.issuer.getOldIds();
-        for(const id of oldIds) {
-          this.canonicalIssuer.getId(id);
-        }
+      // 3.4) Add a mapping of hash to the blank node identifier for the
+      // component that matched (subject or object) to hash to related blank
+      // nodes map, adding an entry as necessary.
+      const hash = this.hashRelatedBlankNode(related, quad, issuer, position);
+      const entries = hashToRelated.get(hash);
+      if(entries) {
+        entries.push(related);
+      } else {
+        hashToRelated.set(hash, [related]);
       }
     }
 
-    /* Note: At this point all blank nodes in the set of RDF quads have been
-    assigned canonical identifiers, which have been stored in the canonical
-    issuer. Here each quad is updated by assigning each of its blank nodes
-    its new identifier. */
+    return hashToRelated;
+  }
+};
 
-    // 7) For each quad, quad, in input dataset:
-    const normalized = [];
-    for(const quad of this.quads) {
-      // 7.1) Create a copy, quad copy, of quad and replace any existing
-      // blank node identifiers using the canonical identifiers
-      // previously issued by canonical issuer.
-      // Note: We optimize away the copy here.
-      const nQuad = NQuads.serializeQuadComponents(
-        this._componentWithCanonicalId({component: quad.subject}),
-        quad.predicate,
-        this._componentWithCanonicalId({component: quad.object}),
-        this._componentWithCanonicalId({component: quad.graph})
-      );
-      // 7.2) Add quad copy to the normalized dataset.
-      normalized.push(nQuad);
-    }
 
-    // sort normalized output
-    normalized.sort();
+/***/ }),
 
-    // 8) Return the normalized dataset.
-    return normalized.join('');
-  }
+/***/ "./node_modules/rdf-canonize/lib/index.js":
+/*!************************************************!*\
+  !*** ./node_modules/rdf-canonize/lib/index.js ***!
+  \************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-  // 4.6) Hash First Degree Quads
-  hashFirstDegreeQuads(id) {
-    // 1) Initialize nquads to an empty list. It will be used to store quads in
-    // N-Quads format.
-    const nquads = [];
+"use strict";
+/**
+ * An implementation of the RDF Dataset Normalization specification.
+ * This library works in the browser and node.js.
+ *
+ * BSD 3-Clause License
+ * Copyright (c) 2016-2022 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.
+ */
 
-    // 2) Get the list of quads `quads` associated with the reference blank node
-    // identifier in the blank node to quads map.
-    const info = this.blankNodeInfo.get(id);
-    const quads = info.quads;
 
-    // 3) For each quad `quad` in `quads`:
-    for(const quad of quads) {
-      // 3.1) Serialize the quad in N-Quads format with the following special
-      // rule:
+const URDNA2015 = __webpack_require__(/*! ./URDNA2015 */ "./node_modules/rdf-canonize/lib/URDNA2015.js");
+const URGNA2012 = __webpack_require__(/*! ./URGNA2012 */ "./node_modules/rdf-canonize/lib/URGNA2012.js");
+const URDNA2015Sync = __webpack_require__(/*! ./URDNA2015Sync */ "./node_modules/rdf-canonize/lib/URDNA2015Sync.js");
+const URGNA2012Sync = __webpack_require__(/*! ./URGNA2012Sync */ "./node_modules/rdf-canonize/lib/URGNA2012Sync.js");
 
-      // 3.1.1) If any component in quad is an blank node, then serialize it
-      // using a special identifier as follows:
-      const copy = {
-        subject: null, predicate: quad.predicate, object: null, graph: null
-      };
-      // 3.1.2) If the blank node's existing blank node identifier matches
-      // the reference blank node identifier then use the blank node
-      // identifier _:a, otherwise, use the blank node identifier _:z.
-      copy.subject = this.modifyFirstDegreeComponent(
-        id, quad.subject, 'subject');
-      copy.object = this.modifyFirstDegreeComponent(
-        id, quad.object, 'object');
-      copy.graph = this.modifyFirstDegreeComponent(
-        id, quad.graph, 'graph');
-      nquads.push(NQuads.serializeQuad(copy));
-    }
+// optional native support
+let rdfCanonizeNative;
+try {
+  rdfCanonizeNative = __webpack_require__(/*! rdf-canonize-native */ "?2b19");
+} catch(e) {}
 
-    // 4) Sort nquads in lexicographical order.
-    nquads.sort();
+// expose helpers
+exports.NQuads = __webpack_require__(/*! ./NQuads */ "./node_modules/rdf-canonize/lib/NQuads.js");
+exports.IdentifierIssuer = __webpack_require__(/*! ./IdentifierIssuer */ "./node_modules/rdf-canonize/lib/IdentifierIssuer.js");
 
-    // 5) Return the hash that results from passing the sorted, joined nquads
-    // through the hash algorithm.
-    const md = this.createMessageDigest();
-    for(const nquad of nquads) {
-      md.update(nquad);
-    }
-    info.hash = md.digest();
-    return info.hash;
+/**
+ * Get or set native API.
+ *
+ * @param api the native API.
+ *
+ * @return the currently set native API.
+ */
+exports._rdfCanonizeNative = function(api) {
+  if(api) {
+    rdfCanonizeNative = api;
   }
+  return rdfCanonizeNative;
+};
 
-  // 4.7) Hash Related Blank Node
-  hashRelatedBlankNode(related, quad, issuer, position) {
-    // 1) Set the identifier to use for related, preferring first the canonical
-    // identifier for related if issued, second the identifier issued by issuer
-    // if issued, and last, if necessary, the result of the Hash First Degree
-    // Quads algorithm, passing related.
-    let id;
-    if(this.canonicalIssuer.hasId(related)) {
-      id = this.canonicalIssuer.getId(related);
-    } else if(issuer.hasId(related)) {
-      id = issuer.getId(related);
-    } else {
-      id = this.blankNodeInfo.get(related).hash;
-    }
+/**
+ * Asynchronously canonizes an RDF dataset.
+ *
+ * @param {Array} dataset - The dataset to canonize.
+ * @param {object} options - The options to use:
+ *   {string} algorithm - The canonicalization algorithm to use, `URDNA2015` or
+ *     `URGNA2012`.
+ *   {Function} [createMessageDigest] - A factory function for creating a
+ *     `MessageDigest` interface that overrides the built-in message digest
+ *     implementation used by the canonize algorithm; note that using a hash
+ *     algorithm (or HMAC algorithm) that differs from the one specified by
+ *     the canonize algorithm will result in different output.
+ *   {boolean} [useNative=false] - Use native implementation.
+ *   {number} [maxDeepIterations=Infinity] - The maximum number of times to run
+ *     deep comparison algorithms (such as the N-Degree Hash Quads algorithm
+ *     used in URDNA2015) before bailing out and throwing an error; this is a
+ *     useful setting for preventing wasted CPU cycles or DoS when canonizing
+ *     meaningless or potentially malicious datasets, a recommended value is
+ *     `1`.
+ *
+ * @return a Promise that resolves to the canonicalized RDF Dataset.
+ */
+exports.canonize = async function(dataset, options) {
+  // back-compat with legacy dataset
+  if(!Array.isArray(dataset)) {
+    dataset = exports.NQuads.legacyDatasetToQuads(dataset);
+  }
 
-    // 2) Initialize a string input to the value of position.
-    // Note: We use a hash object instead.
-    const md = this.createMessageDigest();
-    md.update(position);
+  if(options.useNative) {
+    if(!rdfCanonizeNative) {
+      throw new Error('rdf-canonize-native not available');
+    }
+    if(options.createMessageDigest) {
+      throw new Error(
+        '"createMessageDigest" cannot be used with "useNative".');
+    }
+    return new Promise((resolve, reject) =>
+      rdfCanonizeNative.canonize(dataset, options, (err, canonical) =>
+        err ? reject(err) : resolve(canonical)));
+  }
 
-    // 3) If position is not g, append <, the value of the predicate in quad,
-    // and > to input.
-    if(position !== 'g') {
-      md.update(this.getRelatedPredicate(quad));
+  if(options.algorithm === 'URDNA2015') {
+    return new URDNA2015(options).main(dataset);
+  }
+  if(options.algorithm === 'URGNA2012') {
+    if(options.createMessageDigest) {
+      throw new Error(
+        '"createMessageDigest" cannot be used with "URGNA2012".');
     }
+    return new URGNA2012(options).main(dataset);
+  }
+  if(!('algorithm' in options)) {
+    throw new Error('No RDF Dataset Canonicalization algorithm specified.');
+  }
+  throw new Error(
+    'Invalid RDF Dataset Canonicalization algorithm: ' + options.algorithm);
+};
 
-    // 4) Append identifier to input.
-    md.update(id);
+/**
+ * This method is no longer available in the public API, it is for testing
+ * only. It synchronously canonizes an RDF dataset and does not work in the
+ * browser.
+ *
+ * @param {Array} dataset - The dataset to canonize.
+ * @param {object} options - The options to use:
+ *   {string} algorithm - The canonicalization algorithm to use, `URDNA2015` or
+ *     `URGNA2012`.
+ *   {Function} [createMessageDigest] - A factory function for creating a
+ *     `MessageDigest` interface that overrides the built-in message digest
+ *     implementation used by the canonize algorithm; note that using a hash
+ *     algorithm (or HMAC algorithm) that differs from the one specified by
+ *     the canonize algorithm will result in different output.
+ *   {boolean} [useNative=false] - Use native implementation.
+ *   {number} [maxDeepIterations=Infinity] - The maximum number of times to run
+ *     deep comparison algorithms (such as the N-Degree Hash Quads algorithm
+ *     used in URDNA2015) before bailing out and throwing an error; this is a
+ *     useful setting for preventing wasted CPU cycles or DoS when canonizing
+ *     meaningless or potentially malicious datasets, a recommended value is
+ *     `1`.
+ *
+ * @return the RDF dataset in canonical form.
+ */
+exports._canonizeSync = function(dataset, options) {
+  // back-compat with legacy dataset
+  if(!Array.isArray(dataset)) {
+    dataset = exports.NQuads.legacyDatasetToQuads(dataset);
+  }
 
-    // 5) Return the hash that results from passing input through the hash
-    // algorithm.
-    return md.digest();
+  if(options.useNative) {
+    if(!rdfCanonizeNative) {
+      throw new Error('rdf-canonize-native not available');
+    }
+    if(options.createMessageDigest) {
+      throw new Error(
+        '"createMessageDigest" cannot be used with "useNative".');
+    }
+    return rdfCanonizeNative.canonizeSync(dataset, options);
   }
-
-  // 4.8) Hash N-Degree Quads
-  hashNDegreeQuads(id, issuer) {
-    const deepIterations = this.deepIterations.get(id) || 0;
-    if(deepIterations > this.maxDeepIterations) {
+  if(options.algorithm === 'URDNA2015') {
+    return new URDNA2015Sync(options).main(dataset);
+  }
+  if(options.algorithm === 'URGNA2012') {
+    if(options.createMessageDigest) {
       throw new Error(
-        `Maximum deep iterations (${this.maxDeepIterations}) exceeded.`);
+        '"createMessageDigest" cannot be used with "URGNA2012".');
     }
-    this.deepIterations.set(id, deepIterations + 1);
-
-    // 1) Create a hash to related blank nodes map for storing hashes that
-    // identify related blank nodes.
-    // Note: 2) and 3) handled within `createHashToRelated`
-    const md = this.createMessageDigest();
-    const hashToRelated = this.createHashToRelated(id, issuer);
-
-    // 4) Create an empty string, data to hash.
-    // Note: We created a hash object `md` above instead.
+    return new URGNA2012Sync(options).main(dataset);
+  }
+  if(!('algorithm' in options)) {
+    throw new Error('No RDF Dataset Canonicalization algorithm specified.');
+  }
+  throw new Error(
+    'Invalid RDF Dataset Canonicalization algorithm: ' + options.algorithm);
+};
 
-    // 5) For each related hash to blank node list mapping in hash to related
-    // blank nodes map, sorted lexicographically by related hash:
-    const hashes = [...hashToRelated.keys()].sort();
-    for(const hash of hashes) {
-      // 5.1) Append the related hash to the data to hash.
-      md.update(hash);
 
-      // 5.2) Create a string chosen path.
-      let chosenPath = '';
+/***/ }),
 
-      // 5.3) Create an unset chosen issuer variable.
-      let chosenIssuer;
+/***/ "./node_modules/setimmediate/setImmediate.js":
+/*!***************************************************!*\
+  !*** ./node_modules/setimmediate/setImmediate.js ***!
+  \***************************************************/
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
 
-      // 5.4) For each permutation of blank node list:
-      const permuter = new Permuter(hashToRelated.get(hash));
-      while(permuter.hasNext()) {
-        const permutation = permuter.next();
+(function (global, undefined) {
+    "use strict";
 
-        // 5.4.1) Create a copy of issuer, issuer copy.
-        let issuerCopy = issuer.clone();
+    if (global.setImmediate) {
+        return;
+    }
 
-        // 5.4.2) Create a string path.
-        let path = '';
+    var nextHandle = 1; // Spec says greater than zero
+    var tasksByHandle = {};
+    var currentlyRunningATask = false;
+    var doc = global.document;
+    var registerImmediate;
 
-        // 5.4.3) Create a recursion list, to store blank node identifiers
-        // that must be recursively processed by this algorithm.
-        const recursionList = [];
+    function setImmediate(callback) {
+      // Callback can either be a function or a string
+      if (typeof callback !== "function") {
+        callback = new Function("" + callback);
+      }
+      // Copy function arguments
+      var args = new Array(arguments.length - 1);
+      for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i + 1];
+      }
+      // Store and register the task
+      var task = { callback: callback, args: args };
+      tasksByHandle[nextHandle] = task;
+      registerImmediate(nextHandle);
+      return nextHandle++;
+    }
 
-        // 5.4.4) For each related in permutation:
-        let nextPermutation = false;
-        for(const related of permutation) {
-          // 5.4.4.1) If a canonical identifier has been issued for
-          // related, append it to path.
-          if(this.canonicalIssuer.hasId(related)) {
-            path += this.canonicalIssuer.getId(related);
-          } else {
-            // 5.4.4.2) Otherwise:
-            // 5.4.4.2.1) If issuer copy has not issued an identifier for
-            // related, append related to recursion list.
-            if(!issuerCopy.hasId(related)) {
-              recursionList.push(related);
-            }
-            // 5.4.4.2.2) Use the Issue Identifier algorithm, passing
-            // issuer copy and related and append the result to path.
-            path += issuerCopy.getId(related);
-          }
+    function clearImmediate(handle) {
+        delete tasksByHandle[handle];
+    }
 
-          // 5.4.4.3) If chosen path is not empty and the length of path
-          // is greater than or equal to the length of chosen path and
-          // path is lexicographically greater than chosen path, then
-          // skip to the next permutation.
-          // Note: Comparing path length to chosen path length can be optimized
-          // away; only compare lexicographically.
-          if(chosenPath.length !== 0 && path > chosenPath) {
-            nextPermutation = true;
+    function run(task) {
+        var callback = task.callback;
+        var args = task.args;
+        switch (args.length) {
+        case 0:
+            callback();
             break;
-          }
-        }
-
-        if(nextPermutation) {
-          continue;
-        }
-
-        // 5.4.5) For each related in recursion list:
-        for(const related of recursionList) {
-          // 5.4.5.1) Set result to the result of recursively executing
-          // the Hash N-Degree Quads algorithm, passing related for
-          // identifier and issuer copy for path identifier issuer.
-          const result = this.hashNDegreeQuads(related, issuerCopy);
-
-          // 5.4.5.2) Use the Issue Identifier algorithm, passing issuer
-          // copy and related and append the result to path.
-          path += issuerCopy.getId(related);
-
-          // 5.4.5.3) Append <, the hash in result, and > to path.
-          path += `<${result.hash}>`;
-
-          // 5.4.5.4) Set issuer copy to the identifier issuer in
-          // result.
-          issuerCopy = result.issuer;
-
-          // 5.4.5.5) If chosen path is not empty and the length of path
-          // is greater than or equal to the length of chosen path and
-          // path is lexicographically greater than chosen path, then
-          // skip to the next permutation.
-          // Note: Comparing path length to chosen path length can be optimized
-          // away; only compare lexicographically.
-          if(chosenPath.length !== 0 && path > chosenPath) {
-            nextPermutation = true;
+        case 1:
+            callback(args[0]);
+            break;
+        case 2:
+            callback(args[0], args[1]);
+            break;
+        case 3:
+            callback(args[0], args[1], args[2]);
+            break;
+        default:
+            callback.apply(undefined, args);
             break;
-          }
-        }
-
-        if(nextPermutation) {
-          continue;
-        }
-
-        // 5.4.6) If chosen path is empty or path is lexicographically
-        // less than chosen path, set chosen path to path and chosen
-        // issuer to issuer copy.
-        if(chosenPath.length === 0 || path < chosenPath) {
-          chosenPath = path;
-          chosenIssuer = issuerCopy;
         }
-      }
-
-      // 5.5) Append chosen path to data to hash.
-      md.update(chosenPath);
-
-      // 5.6) Replace issuer, by reference, with chosen issuer.
-      issuer = chosenIssuer;
     }
 
-    // 6) Return issuer and the hash that results from passing data to hash
-    // through the hash algorithm.
-    return {hash: md.digest(), issuer};
-  }
-
-  // helper for modifying component during Hash First Degree Quads
-  modifyFirstDegreeComponent(id, component) {
-    if(component.termType !== 'BlankNode') {
-      return component;
+    function runIfPresent(handle) {
+        // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
+        // So if we're currently running a task, we'll need to delay this invocation.
+        if (currentlyRunningATask) {
+            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
+            // "too much recursion" error.
+            setTimeout(runIfPresent, 0, handle);
+        } else {
+            var task = tasksByHandle[handle];
+            if (task) {
+                currentlyRunningATask = true;
+                try {
+                    run(task);
+                } finally {
+                    clearImmediate(handle);
+                    currentlyRunningATask = false;
+                }
+            }
+        }
     }
-    /* Note: A mistake in the URDNA2015 spec that made its way into
-    implementations (and therefore must stay to avoid interop breakage)
-    resulted in an assigned canonical ID, if available for
-    `component.value`, not being used in place of `_:a`/`_:z`, so
-    we don't use it here. */
-    return {
-      termType: 'BlankNode',
-      value: component.value === id ? '_:a' : '_:z'
-    };
-  }
-
-  // helper for getting a related predicate
-  getRelatedPredicate(quad) {
-    return `<${quad.predicate.value}>`;
-  }
-
-  // helper for creating hash to related blank nodes map
-  createHashToRelated(id, issuer) {
-    // 1) Create a hash to related blank nodes map for storing hashes that
-    // identify related blank nodes.
-    const hashToRelated = new Map();
-
-    // 2) Get a reference, quads, to the list of quads in the blank node to
-    // quads map for the key identifier.
-    const quads = this.blankNodeInfo.get(id).quads;
 
-    // 3) For each quad in quads:
-    for(const quad of quads) {
-      // 3.1) For each component in quad, if component is the subject, object,
-      // or graph name and it is a blank node that is not identified by
-      // identifier:
-      // steps 3.1.1 and 3.1.2 occur in helpers:
-      this._addRelatedBlankNodeHash({
-        quad, component: quad.subject, position: 's',
-        id, issuer, hashToRelated
-      });
-      this._addRelatedBlankNodeHash({
-        quad, component: quad.object, position: 'o',
-        id, issuer, hashToRelated
-      });
-      this._addRelatedBlankNodeHash({
-        quad, component: quad.graph, position: 'g',
-        id, issuer, hashToRelated
-      });
+    function installNextTickImplementation() {
+        registerImmediate = function(handle) {
+            process.nextTick(function () { runIfPresent(handle); });
+        };
     }
 
-    return hashToRelated;
-  }
+    function canUsePostMessage() {
+        // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+        // where `global.postMessage` means something completely different and can't be used for this purpose.
+        if (global.postMessage && !global.importScripts) {
+            var postMessageIsAsynchronous = true;
+            var oldOnMessage = global.onmessage;
+            global.onmessage = function() {
+                postMessageIsAsynchronous = false;
+            };
+            global.postMessage("", "*");
+            global.onmessage = oldOnMessage;
+            return postMessageIsAsynchronous;
+        }
+    }
 
-  _hashAndTrackBlankNode({id, hashToBlankNodes}) {
-    // 5.3.1) Create a hash, hash, according to the Hash First Degree
-    // Quads algorithm.
-    const hash = this.hashFirstDegreeQuads(id);
+    function installPostMessageImplementation() {
+        // Installs an event handler on `global` for the `message` event: see
+        // * https://developer.mozilla.org/en/DOM/window.postMessage
+        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
 
-    // 5.3.2) Add hash and identifier to hash to blank nodes map,
-    // creating a new entry if necessary.
-    const idList = hashToBlankNodes.get(hash);
-    if(!idList) {
-      hashToBlankNodes.set(hash, [id]);
-    } else {
-      idList.push(id);
-    }
-  }
+        var messagePrefix = "setImmediate$" + Math.random() + "$";
+        var onGlobalMessage = function(event) {
+            if (event.source === global &&
+                typeof event.data === "string" &&
+                event.data.indexOf(messagePrefix) === 0) {
+                runIfPresent(+event.data.slice(messagePrefix.length));
+            }
+        };
 
-  _addBlankNodeQuadInfo({quad, component}) {
-    if(component.termType !== 'BlankNode') {
-      return;
-    }
-    const id = component.value;
-    const info = this.blankNodeInfo.get(id);
-    if(info) {
-      info.quads.add(quad);
-    } else {
-      this.blankNodeInfo.set(id, {quads: new Set([quad]), hash: null});
-    }
-  }
+        if (global.addEventListener) {
+            global.addEventListener("message", onGlobalMessage, false);
+        } else {
+            global.attachEvent("onmessage", onGlobalMessage);
+        }
 
-  _addRelatedBlankNodeHash(
-    {quad, component, position, id, issuer, hashToRelated}) {
-    if(!(component.termType === 'BlankNode' && component.value !== id)) {
-      return;
+        registerImmediate = function(handle) {
+            global.postMessage(messagePrefix + handle, "*");
+        };
     }
-    // 3.1.1) Set hash to the result of the Hash Related Blank Node
-    // algorithm, passing the blank node identifier for component as
-    // related, quad, path identifier issuer as issuer, and position as
-    // either s, o, or g based on whether component is a subject, object,
-    // graph name, respectively.
-    const related = component.value;
-    const hash = this.hashRelatedBlankNode(related, quad, issuer, position);
 
-    // 3.1.2) Add a mapping of hash to the blank node identifier for
-    // component to hash to related blank nodes map, adding an entry as
-    // necessary.
-    const entries = hashToRelated.get(hash);
-    if(entries) {
-      entries.push(related);
-    } else {
-      hashToRelated.set(hash, [related]);
+    function installMessageChannelImplementation() {
+        var channel = new MessageChannel();
+        channel.port1.onmessage = function(event) {
+            var handle = event.data;
+            runIfPresent(handle);
+        };
+
+        registerImmediate = function(handle) {
+            channel.port2.postMessage(handle);
+        };
     }
-  }
 
-  // canonical ids for 7.1
-  _componentWithCanonicalId({component}) {
-    if(component.termType === 'BlankNode' &&
-      !component.value.startsWith(this.canonicalIssuer.prefix)) {
-      // create new BlankNode
-      return {
-        termType: 'BlankNode',
-        value: this.canonicalIssuer.getId(component.value)
-      };
+    function installReadyStateChangeImplementation() {
+        var html = doc.documentElement;
+        registerImmediate = function(handle) {
+            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+            var script = doc.createElement("script");
+            script.onreadystatechange = function () {
+                runIfPresent(handle);
+                script.onreadystatechange = null;
+                html.removeChild(script);
+                script = null;
+            };
+            html.appendChild(script);
+        };
     }
-    return component;
-  }
-};
 
-function _stringHashCompare(a, b) {
-  return a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0;
-}
+    function installSetTimeoutImplementation() {
+        registerImmediate = function(handle) {
+            setTimeout(runIfPresent, 0, handle);
+        };
+    }
 
+    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
+    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
+    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
 
-/***/ }),
+    // Don't get fooled by e.g. browserify environments.
+    if ({}.toString.call(global.process) === "[object process]") {
+        // For Node.js before 0.9
+        installNextTickImplementation();
 
-/***/ "./node_modules/rdf-canonize/lib/URGNA2012.js":
-/*!****************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/URGNA2012.js ***!
-  \****************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+    } else if (canUsePostMessage()) {
+        // For non-IE10 modern browsers
+        installPostMessageImplementation();
 
-"use strict";
-/*!
- * Copyright (c) 2016-2022 Digital Bazaar, Inc. All rights reserved.
- */
+    } else if (global.MessageChannel) {
+        // For web workers, where supported
+        installMessageChannelImplementation();
 
+    } else if (doc && "onreadystatechange" in doc.createElement("script")) {
+        // For IE 6–8
+        installReadyStateChangeImplementation();
 
-const MessageDigest = __webpack_require__(/*! ./MessageDigest */ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js");
-const URDNA2015 = __webpack_require__(/*! ./URDNA2015 */ "./node_modules/rdf-canonize/lib/URDNA2015.js");
+    } else {
+        // For older browsers
+        installSetTimeoutImplementation();
+    }
 
-module.exports = class URDNA2012 extends URDNA2015 {
-  constructor() {
-    super();
-    this.name = 'URGNA2012';
-    this.createMessageDigest = () => new MessageDigest('sha1');
-  }
+    attachTo.setImmediate = setImmediate;
+    attachTo.clearImmediate = clearImmediate;
+}(typeof self === "undefined" ? typeof __webpack_require__.g === "undefined" ? this : __webpack_require__.g : self));
 
-  // helper for modifying component during Hash First Degree Quads
-  modifyFirstDegreeComponent(id, component, key) {
-    if(component.termType !== 'BlankNode') {
-      return component;
-    }
-    if(key === 'graph') {
-      return {
-        termType: 'BlankNode',
-        value: '_:g'
-      };
-    }
-    return {
-      termType: 'BlankNode',
-      value: (component.value === id ? '_:a' : '_:z')
-    };
-  }
 
-  // helper for getting a related predicate
-  getRelatedPredicate(quad) {
-    return quad.predicate.value;
-  }
+/***/ }),
 
-  // helper for creating hash to related blank nodes map
-  async createHashToRelated(id, issuer) {
-    // 1) Create a hash to related blank nodes map for storing hashes that
-    // identify related blank nodes.
-    const hashToRelated = new Map();
+/***/ "./node_modules/yallist/iterator.js":
+/*!******************************************!*\
+  !*** ./node_modules/yallist/iterator.js ***!
+  \******************************************/
+/***/ ((module) => {
 
-    // 2) Get a reference, quads, to the list of quads in the blank node to
-    // quads map for the key identifier.
-    const quads = this.blankNodeInfo.get(id).quads;
+"use strict";
 
-    // 3) For each quad in quads:
-    let i = 0;
-    for(const quad of quads) {
-      // 3.1) If the quad's subject is a blank node that does not match
-      // identifier, set hash to the result of the Hash Related Blank Node
-      // algorithm, passing the blank node identifier for subject as related,
-      // quad, path identifier issuer as issuer, and p as position.
-      let position;
-      let related;
-      if(quad.subject.termType === 'BlankNode' && quad.subject.value !== id) {
-        related = quad.subject.value;
-        position = 'p';
-      } else if(
-        quad.object.termType === 'BlankNode' && quad.object.value !== id) {
-        // 3.2) Otherwise, if quad's object is a blank node that does not match
-        // identifier, to the result of the Hash Related Blank Node algorithm,
-        // passing the blank node identifier for object as related, quad, path
-        // identifier issuer as issuer, and r as position.
-        related = quad.object.value;
-        position = 'r';
-      } else {
-        // 3.3) Otherwise, continue to the next quad.
-        continue;
-      }
-      // Note: batch hashing related blank nodes 100 at a time
-      if(++i % 100 === 0) {
-        await this._yield();
-      }
-      // 3.4) Add a mapping of hash to the blank node identifier for the
-      // component that matched (subject or object) to hash to related blank
-      // nodes map, adding an entry as necessary.
-      const hash = await this.hashRelatedBlankNode(
-        related, quad, issuer, position);
-      const entries = hashToRelated.get(hash);
-      if(entries) {
-        entries.push(related);
-      } else {
-        hashToRelated.set(hash, [related]);
-      }
+module.exports = function (Yallist) {
+  Yallist.prototype[Symbol.iterator] = function* () {
+    for (let walker = this.head; walker; walker = walker.next) {
+      yield walker.value
     }
-
-    return hashToRelated;
   }
-};
-
+}
 
-/***/ }),
 
-/***/ "./node_modules/rdf-canonize/lib/URGNA2012Sync.js":
-/*!********************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/URGNA2012Sync.js ***!
-  \********************************************************/
+/***/ }),
+
+/***/ "./node_modules/yallist/yallist.js":
+/*!*****************************************!*\
+  !*** ./node_modules/yallist/yallist.js ***!
+  \*****************************************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
-/*!
- * Copyright (c) 2016-2021 Digital Bazaar, Inc. All rights reserved.
- */
 
+module.exports = Yallist
 
-const MessageDigest = __webpack_require__(/*! ./MessageDigest */ "./node_modules/rdf-canonize/lib/MessageDigest-browser.js");
-const URDNA2015Sync = __webpack_require__(/*! ./URDNA2015Sync */ "./node_modules/rdf-canonize/lib/URDNA2015Sync.js");
+Yallist.Node = Node
+Yallist.create = Yallist
 
-module.exports = class URDNA2012Sync extends URDNA2015Sync {
-  constructor() {
-    super();
-    this.name = 'URGNA2012';
-    this.createMessageDigest = () => new MessageDigest('sha1');
+function Yallist (list) {
+  var self = this
+  if (!(self instanceof Yallist)) {
+    self = new Yallist()
   }
 
-  // helper for modifying component during Hash First Degree Quads
-  modifyFirstDegreeComponent(id, component, key) {
-    if(component.termType !== 'BlankNode') {
-      return component;
-    }
-    if(key === 'graph') {
-      return {
-        termType: 'BlankNode',
-        value: '_:g'
-      };
+  self.tail = null
+  self.head = null
+  self.length = 0
+
+  if (list && typeof list.forEach === 'function') {
+    list.forEach(function (item) {
+      self.push(item)
+    })
+  } else if (arguments.length > 0) {
+    for (var i = 0, l = arguments.length; i < l; i++) {
+      self.push(arguments[i])
     }
-    return {
-      termType: 'BlankNode',
-      value: (component.value === id ? '_:a' : '_:z')
-    };
   }
 
-  // helper for getting a related predicate
-  getRelatedPredicate(quad) {
-    return quad.predicate.value;
+  return self
+}
+
+Yallist.prototype.removeNode = function (node) {
+  if (node.list !== this) {
+    throw new Error('removing node which does not belong to this list')
   }
 
-  // helper for creating hash to related blank nodes map
-  createHashToRelated(id, issuer) {
-    // 1) Create a hash to related blank nodes map for storing hashes that
-    // identify related blank nodes.
-    const hashToRelated = new Map();
+  var next = node.next
+  var prev = node.prev
 
-    // 2) Get a reference, quads, to the list of quads in the blank node to
-    // quads map for the key identifier.
-    const quads = this.blankNodeInfo.get(id).quads;
+  if (next) {
+    next.prev = prev
+  }
 
-    // 3) For each quad in quads:
-    for(const quad of quads) {
-      // 3.1) If the quad's subject is a blank node that does not match
-      // identifier, set hash to the result of the Hash Related Blank Node
-      // algorithm, passing the blank node identifier for subject as related,
-      // quad, path identifier issuer as issuer, and p as position.
-      let position;
-      let related;
-      if(quad.subject.termType === 'BlankNode' && quad.subject.value !== id) {
-        related = quad.subject.value;
-        position = 'p';
-      } else if(
-        quad.object.termType === 'BlankNode' && quad.object.value !== id) {
-        // 3.2) Otherwise, if quad's object is a blank node that does not match
-        // identifier, to the result of the Hash Related Blank Node algorithm,
-        // passing the blank node identifier for object as related, quad, path
-        // identifier issuer as issuer, and r as position.
-        related = quad.object.value;
-        position = 'r';
-      } else {
-        // 3.3) Otherwise, continue to the next quad.
-        continue;
-      }
-      // 3.4) Add a mapping of hash to the blank node identifier for the
-      // component that matched (subject or object) to hash to related blank
-      // nodes map, adding an entry as necessary.
-      const hash = this.hashRelatedBlankNode(related, quad, issuer, position);
-      const entries = hashToRelated.get(hash);
-      if(entries) {
-        entries.push(related);
-      } else {
-        hashToRelated.set(hash, [related]);
-      }
-    }
+  if (prev) {
+    prev.next = next
+  }
 
-    return hashToRelated;
+  if (node === this.head) {
+    this.head = next
+  }
+  if (node === this.tail) {
+    this.tail = prev
   }
-};
 
+  node.list.length--
+  node.next = null
+  node.prev = null
+  node.list = null
 
-/***/ }),
+  return next
+}
 
-/***/ "./node_modules/rdf-canonize/lib/index.js":
-/*!************************************************!*\
-  !*** ./node_modules/rdf-canonize/lib/index.js ***!
-  \************************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+Yallist.prototype.unshiftNode = function (node) {
+  if (node === this.head) {
+    return
+  }
 
-"use strict";
-/**
- * An implementation of the RDF Dataset Normalization specification.
- * This library works in the browser and node.js.
- *
- * BSD 3-Clause License
- * Copyright (c) 2016-2022 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.
- */
+  if (node.list) {
+    node.list.removeNode(node)
+  }
 
+  var head = this.head
+  node.list = this
+  node.next = head
+  if (head) {
+    head.prev = node
+  }
 
-const URDNA2015 = __webpack_require__(/*! ./URDNA2015 */ "./node_modules/rdf-canonize/lib/URDNA2015.js");
-const URGNA2012 = __webpack_require__(/*! ./URGNA2012 */ "./node_modules/rdf-canonize/lib/URGNA2012.js");
-const URDNA2015Sync = __webpack_require__(/*! ./URDNA2015Sync */ "./node_modules/rdf-canonize/lib/URDNA2015Sync.js");
-const URGNA2012Sync = __webpack_require__(/*! ./URGNA2012Sync */ "./node_modules/rdf-canonize/lib/URGNA2012Sync.js");
+  this.head = node
+  if (!this.tail) {
+    this.tail = node
+  }
+  this.length++
+}
 
-// optional native support
-let rdfCanonizeNative;
-try {
-  rdfCanonizeNative = __webpack_require__(/*! rdf-canonize-native */ "?2b19");
-} catch(e) {}
+Yallist.prototype.pushNode = function (node) {
+  if (node === this.tail) {
+    return
+  }
 
-// expose helpers
-exports.NQuads = __webpack_require__(/*! ./NQuads */ "./node_modules/rdf-canonize/lib/NQuads.js");
-exports.IdentifierIssuer = __webpack_require__(/*! ./IdentifierIssuer */ "./node_modules/rdf-canonize/lib/IdentifierIssuer.js");
+  if (node.list) {
+    node.list.removeNode(node)
+  }
 
-/**
- * Get or set native API.
- *
- * @param api the native API.
- *
- * @return the currently set native API.
- */
-exports._rdfCanonizeNative = function(api) {
-  if(api) {
-    rdfCanonizeNative = api;
+  var tail = this.tail
+  node.list = this
+  node.prev = tail
+  if (tail) {
+    tail.next = node
   }
-  return rdfCanonizeNative;
-};
 
-/**
- * Asynchronously canonizes an RDF dataset.
- *
- * @param {Array} dataset - The dataset to canonize.
- * @param {object} options - The options to use:
- *   {string} algorithm - The canonicalization algorithm to use, `URDNA2015` or
- *     `URGNA2012`.
- *   {Function} [createMessageDigest] - A factory function for creating a
- *     `MessageDigest` interface that overrides the built-in message digest
- *     implementation used by the canonize algorithm; note that using a hash
- *     algorithm (or HMAC algorithm) that differs from the one specified by
- *     the canonize algorithm will result in different output.
- *   {boolean} [useNative=false] - Use native implementation.
- *   {number} [maxDeepIterations=Infinity] - The maximum number of times to run
- *     deep comparison algorithms (such as the N-Degree Hash Quads algorithm
- *     used in URDNA2015) before bailing out and throwing an error; this is a
- *     useful setting for preventing wasted CPU cycles or DoS when canonizing
- *     meaningless or potentially malicious datasets, a recommended value is
- *     `1`.
- *
- * @return a Promise that resolves to the canonicalized RDF Dataset.
- */
-exports.canonize = async function(dataset, options) {
-  // back-compat with legacy dataset
-  if(!Array.isArray(dataset)) {
-    dataset = exports.NQuads.legacyDatasetToQuads(dataset);
+  this.tail = node
+  if (!this.head) {
+    this.head = node
+  }
+  this.length++
+}
+
+Yallist.prototype.push = function () {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    push(this, arguments[i])
+  }
+  return this.length
+}
+
+Yallist.prototype.unshift = function () {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    unshift(this, arguments[i])
   }
+  return this.length
+}
 
-  if(options.useNative) {
-    if(!rdfCanonizeNative) {
-      throw new Error('rdf-canonize-native not available');
-    }
-    if(options.createMessageDigest) {
-      throw new Error(
-        '"createMessageDigest" cannot be used with "useNative".');
-    }
-    return new Promise((resolve, reject) =>
-      rdfCanonizeNative.canonize(dataset, options, (err, canonical) =>
-        err ? reject(err) : resolve(canonical)));
+Yallist.prototype.pop = function () {
+  if (!this.tail) {
+    return undefined
   }
 
-  if(options.algorithm === 'URDNA2015') {
-    return new URDNA2015(options).main(dataset);
+  var res = this.tail.value
+  this.tail = this.tail.prev
+  if (this.tail) {
+    this.tail.next = null
+  } else {
+    this.head = null
   }
-  if(options.algorithm === 'URGNA2012') {
-    if(options.createMessageDigest) {
-      throw new Error(
-        '"createMessageDigest" cannot be used with "URGNA2012".');
-    }
-    return new URGNA2012(options).main(dataset);
+  this.length--
+  return res
+}
+
+Yallist.prototype.shift = function () {
+  if (!this.head) {
+    return undefined
   }
-  if(!('algorithm' in options)) {
-    throw new Error('No RDF Dataset Canonicalization algorithm specified.');
+
+  var res = this.head.value
+  this.head = this.head.next
+  if (this.head) {
+    this.head.prev = null
+  } else {
+    this.tail = null
   }
-  throw new Error(
-    'Invalid RDF Dataset Canonicalization algorithm: ' + options.algorithm);
-};
+  this.length--
+  return res
+}
 
-/**
- * This method is no longer available in the public API, it is for testing
- * only. It synchronously canonizes an RDF dataset and does not work in the
- * browser.
- *
- * @param {Array} dataset - The dataset to canonize.
- * @param {object} options - The options to use:
- *   {string} algorithm - The canonicalization algorithm to use, `URDNA2015` or
- *     `URGNA2012`.
- *   {Function} [createMessageDigest] - A factory function for creating a
- *     `MessageDigest` interface that overrides the built-in message digest
- *     implementation used by the canonize algorithm; note that using a hash
- *     algorithm (or HMAC algorithm) that differs from the one specified by
- *     the canonize algorithm will result in different output.
- *   {boolean} [useNative=false] - Use native implementation.
- *   {number} [maxDeepIterations=Infinity] - The maximum number of times to run
- *     deep comparison algorithms (such as the N-Degree Hash Quads algorithm
- *     used in URDNA2015) before bailing out and throwing an error; this is a
- *     useful setting for preventing wasted CPU cycles or DoS when canonizing
- *     meaningless or potentially malicious datasets, a recommended value is
- *     `1`.
- *
- * @return the RDF dataset in canonical form.
- */
-exports._canonizeSync = function(dataset, options) {
-  // back-compat with legacy dataset
-  if(!Array.isArray(dataset)) {
-    dataset = exports.NQuads.legacyDatasetToQuads(dataset);
+Yallist.prototype.forEach = function (fn, thisp) {
+  thisp = thisp || this
+  for (var walker = this.head, i = 0; walker !== null; i++) {
+    fn.call(thisp, walker.value, i, this)
+    walker = walker.next
   }
+}
 
-  if(options.useNative) {
-    if(!rdfCanonizeNative) {
-      throw new Error('rdf-canonize-native not available');
-    }
-    if(options.createMessageDigest) {
-      throw new Error(
-        '"createMessageDigest" cannot be used with "useNative".');
-    }
-    return rdfCanonizeNative.canonizeSync(dataset, options);
+Yallist.prototype.forEachReverse = function (fn, thisp) {
+  thisp = thisp || this
+  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+    fn.call(thisp, walker.value, i, this)
+    walker = walker.prev
   }
-  if(options.algorithm === 'URDNA2015') {
-    return new URDNA2015Sync(options).main(dataset);
+}
+
+Yallist.prototype.get = function (n) {
+  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+    // abort out of the list early if we hit a cycle
+    walker = walker.next
   }
-  if(options.algorithm === 'URGNA2012') {
-    if(options.createMessageDigest) {
-      throw new Error(
-        '"createMessageDigest" cannot be used with "URGNA2012".');
-    }
-    return new URGNA2012Sync(options).main(dataset);
+  if (i === n && walker !== null) {
+    return walker.value
   }
-  if(!('algorithm' in options)) {
-    throw new Error('No RDF Dataset Canonicalization algorithm specified.');
+}
+
+Yallist.prototype.getReverse = function (n) {
+  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+    // abort out of the list early if we hit a cycle
+    walker = walker.prev
   }
-  throw new Error(
-    'Invalid RDF Dataset Canonicalization algorithm: ' + options.algorithm);
-};
+  if (i === n && walker !== null) {
+    return walker.value
+  }
+}
 
+Yallist.prototype.map = function (fn, thisp) {
+  thisp = thisp || this
+  var res = new Yallist()
+  for (var walker = this.head; walker !== null;) {
+    res.push(fn.call(thisp, walker.value, this))
+    walker = walker.next
+  }
+  return res
+}
 
-/***/ }),
+Yallist.prototype.mapReverse = function (fn, thisp) {
+  thisp = thisp || this
+  var res = new Yallist()
+  for (var walker = this.tail; walker !== null;) {
+    res.push(fn.call(thisp, walker.value, this))
+    walker = walker.prev
+  }
+  return res
+}
 
-/***/ "./node_modules/setimmediate/setImmediate.js":
-/*!***************************************************!*\
-  !*** ./node_modules/setimmediate/setImmediate.js ***!
-  \***************************************************/
-/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+Yallist.prototype.reduce = function (fn, initial) {
+  var acc
+  var walker = this.head
+  if (arguments.length > 1) {
+    acc = initial
+  } else if (this.head) {
+    walker = this.head.next
+    acc = this.head.value
+  } else {
+    throw new TypeError('Reduce of empty list with no initial value')
+  }
 
-(function (global, undefined) {
-    "use strict";
+  for (var i = 0; walker !== null; i++) {
+    acc = fn(acc, walker.value, i)
+    walker = walker.next
+  }
 
-    if (global.setImmediate) {
-        return;
-    }
+  return acc
+}
 
-    var nextHandle = 1; // Spec says greater than zero
-    var tasksByHandle = {};
-    var currentlyRunningATask = false;
-    var doc = global.document;
-    var registerImmediate;
+Yallist.prototype.reduceReverse = function (fn, initial) {
+  var acc
+  var walker = this.tail
+  if (arguments.length > 1) {
+    acc = initial
+  } else if (this.tail) {
+    walker = this.tail.prev
+    acc = this.tail.value
+  } else {
+    throw new TypeError('Reduce of empty list with no initial value')
+  }
 
-    function setImmediate(callback) {
-      // Callback can either be a function or a string
-      if (typeof callback !== "function") {
-        callback = new Function("" + callback);
-      }
-      // Copy function arguments
-      var args = new Array(arguments.length - 1);
-      for (var i = 0; i < args.length; i++) {
-          args[i] = arguments[i + 1];
-      }
-      // Store and register the task
-      var task = { callback: callback, args: args };
-      tasksByHandle[nextHandle] = task;
-      registerImmediate(nextHandle);
-      return nextHandle++;
-    }
+  for (var i = this.length - 1; walker !== null; i--) {
+    acc = fn(acc, walker.value, i)
+    walker = walker.prev
+  }
 
-    function clearImmediate(handle) {
-        delete tasksByHandle[handle];
-    }
+  return acc
+}
 
-    function run(task) {
-        var callback = task.callback;
-        var args = task.args;
-        switch (args.length) {
-        case 0:
-            callback();
-            break;
-        case 1:
-            callback(args[0]);
-            break;
-        case 2:
-            callback(args[0], args[1]);
-            break;
-        case 3:
-            callback(args[0], args[1], args[2]);
-            break;
-        default:
-            callback.apply(undefined, args);
-            break;
-        }
-    }
+Yallist.prototype.toArray = function () {
+  var arr = new Array(this.length)
+  for (var i = 0, walker = this.head; walker !== null; i++) {
+    arr[i] = walker.value
+    walker = walker.next
+  }
+  return arr
+}
+
+Yallist.prototype.toArrayReverse = function () {
+  var arr = new Array(this.length)
+  for (var i = 0, walker = this.tail; walker !== null; i++) {
+    arr[i] = walker.value
+    walker = walker.prev
+  }
+  return arr
+}
 
-    function runIfPresent(handle) {
-        // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
-        // So if we're currently running a task, we'll need to delay this invocation.
-        if (currentlyRunningATask) {
-            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
-            // "too much recursion" error.
-            setTimeout(runIfPresent, 0, handle);
-        } else {
-            var task = tasksByHandle[handle];
-            if (task) {
-                currentlyRunningATask = true;
-                try {
-                    run(task);
-                } finally {
-                    clearImmediate(handle);
-                    currentlyRunningATask = false;
-                }
-            }
-        }
-    }
+Yallist.prototype.slice = function (from, to) {
+  to = to || this.length
+  if (to < 0) {
+    to += this.length
+  }
+  from = from || 0
+  if (from < 0) {
+    from += this.length
+  }
+  var ret = new Yallist()
+  if (to < from || to < 0) {
+    return ret
+  }
+  if (from < 0) {
+    from = 0
+  }
+  if (to > this.length) {
+    to = this.length
+  }
+  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+    walker = walker.next
+  }
+  for (; walker !== null && i < to; i++, walker = walker.next) {
+    ret.push(walker.value)
+  }
+  return ret
+}
 
-    function installNextTickImplementation() {
-        registerImmediate = function(handle) {
-            process.nextTick(function () { runIfPresent(handle); });
-        };
-    }
+Yallist.prototype.sliceReverse = function (from, to) {
+  to = to || this.length
+  if (to < 0) {
+    to += this.length
+  }
+  from = from || 0
+  if (from < 0) {
+    from += this.length
+  }
+  var ret = new Yallist()
+  if (to < from || to < 0) {
+    return ret
+  }
+  if (from < 0) {
+    from = 0
+  }
+  if (to > this.length) {
+    to = this.length
+  }
+  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+    walker = walker.prev
+  }
+  for (; walker !== null && i > from; i--, walker = walker.prev) {
+    ret.push(walker.value)
+  }
+  return ret
+}
 
-    function canUsePostMessage() {
-        // The test against `importScripts` prevents this implementation from being installed inside a web worker,
-        // where `global.postMessage` means something completely different and can't be used for this purpose.
-        if (global.postMessage && !global.importScripts) {
-            var postMessageIsAsynchronous = true;
-            var oldOnMessage = global.onmessage;
-            global.onmessage = function() {
-                postMessageIsAsynchronous = false;
-            };
-            global.postMessage("", "*");
-            global.onmessage = oldOnMessage;
-            return postMessageIsAsynchronous;
-        }
-    }
+Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
+  if (start > this.length) {
+    start = this.length - 1
+  }
+  if (start < 0) {
+    start = this.length + start;
+  }
 
-    function installPostMessageImplementation() {
-        // Installs an event handler on `global` for the `message` event: see
-        // * https://developer.mozilla.org/en/DOM/window.postMessage
-        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
+  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+    walker = walker.next
+  }
 
-        var messagePrefix = "setImmediate$" + Math.random() + "$";
-        var onGlobalMessage = function(event) {
-            if (event.source === global &&
-                typeof event.data === "string" &&
-                event.data.indexOf(messagePrefix) === 0) {
-                runIfPresent(+event.data.slice(messagePrefix.length));
-            }
-        };
+  var ret = []
+  for (var i = 0; walker && i < deleteCount; i++) {
+    ret.push(walker.value)
+    walker = this.removeNode(walker)
+  }
+  if (walker === null) {
+    walker = this.tail
+  }
 
-        if (global.addEventListener) {
-            global.addEventListener("message", onGlobalMessage, false);
-        } else {
-            global.attachEvent("onmessage", onGlobalMessage);
-        }
+  if (walker !== this.head && walker !== this.tail) {
+    walker = walker.prev
+  }
 
-        registerImmediate = function(handle) {
-            global.postMessage(messagePrefix + handle, "*");
-        };
-    }
+  for (var i = 0; i < nodes.length; i++) {
+    walker = insert(this, walker, nodes[i])
+  }
+  return ret;
+}
 
-    function installMessageChannelImplementation() {
-        var channel = new MessageChannel();
-        channel.port1.onmessage = function(event) {
-            var handle = event.data;
-            runIfPresent(handle);
-        };
+Yallist.prototype.reverse = function () {
+  var head = this.head
+  var tail = this.tail
+  for (var walker = head; walker !== null; walker = walker.prev) {
+    var p = walker.prev
+    walker.prev = walker.next
+    walker.next = p
+  }
+  this.head = tail
+  this.tail = head
+  return this
+}
 
-        registerImmediate = function(handle) {
-            channel.port2.postMessage(handle);
-        };
-    }
+function insert (self, node, value) {
+  var inserted = node === self.head ?
+    new Node(value, null, node, self) :
+    new Node(value, node, node.next, self)
 
-    function installReadyStateChangeImplementation() {
-        var html = doc.documentElement;
-        registerImmediate = function(handle) {
-            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
-            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
-            var script = doc.createElement("script");
-            script.onreadystatechange = function () {
-                runIfPresent(handle);
-                script.onreadystatechange = null;
-                html.removeChild(script);
-                script = null;
-            };
-            html.appendChild(script);
-        };
-    }
+  if (inserted.next === null) {
+    self.tail = inserted
+  }
+  if (inserted.prev === null) {
+    self.head = inserted
+  }
 
-    function installSetTimeoutImplementation() {
-        registerImmediate = function(handle) {
-            setTimeout(runIfPresent, 0, handle);
-        };
-    }
+  self.length++
 
-    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
-    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
-    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
+  return inserted
+}
 
-    // Don't get fooled by e.g. browserify environments.
-    if ({}.toString.call(global.process) === "[object process]") {
-        // For Node.js before 0.9
-        installNextTickImplementation();
+function push (self, item) {
+  self.tail = new Node(item, self.tail, null, self)
+  if (!self.head) {
+    self.head = self.tail
+  }
+  self.length++
+}
 
-    } else if (canUsePostMessage()) {
-        // For non-IE10 modern browsers
-        installPostMessageImplementation();
+function unshift (self, item) {
+  self.head = new Node(item, null, self.head, self)
+  if (!self.tail) {
+    self.tail = self.head
+  }
+  self.length++
+}
 
-    } else if (global.MessageChannel) {
-        // For web workers, where supported
-        installMessageChannelImplementation();
+function Node (value, prev, next, list) {
+  if (!(this instanceof Node)) {
+    return new Node(value, prev, next, list)
+  }
 
-    } else if (doc && "onreadystatechange" in doc.createElement("script")) {
-        // For IE 6–8
-        installReadyStateChangeImplementation();
+  this.list = list
+  this.value = value
 
-    } else {
-        // For older browsers
-        installSetTimeoutImplementation();
-    }
+  if (prev) {
+    prev.next = this
+    this.prev = prev
+  } else {
+    this.prev = null
+  }
 
-    attachTo.setImmediate = setImmediate;
-    attachTo.clearImmediate = clearImmediate;
-}(typeof self === "undefined" ? typeof __webpack_require__.g === "undefined" ? this : __webpack_require__.g : self));
+  if (next) {
+    next.prev = this
+    this.next = next
+  } else {
+    this.next = null
+  }
+}
+
+try {
+  // add if support for Symbol.iterator is present
+  __webpack_require__(/*! ./iterator.js */ "./node_modules/yallist/iterator.js")(Yallist)
+} catch (er) {}
 
 
 /***/ })